{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import necessary libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import preprocessing\n",
    "from tensorflow.keras.models import load_model\n",
    "import os\n",
    "# import talib\n",
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load gdp data\n",
    "df = pd.read_csv('GDP.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>GDP</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-07-01</th>\n",
       "      <td>20749.752</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-10-01</th>\n",
       "      <td>20897.804</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01</th>\n",
       "      <td>21098.827</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-01</th>\n",
       "      <td>21340.267</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-01</th>\n",
       "      <td>21542.104</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  GDP\n",
       "DATE                 \n",
       "2018-07-01  20749.752\n",
       "2018-10-01  20897.804\n",
       "2019-01-01  21098.827\n",
       "2019-04-01  21340.267\n",
       "2019-07-01  21542.104"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#set look-back to 12 and forecast out to 2 \n",
    "LOOK_BACK = 12\n",
    "FORECAST_OUT = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# get rid of any nan values just in case\n",
    "df.fillna(method='ffill', inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(291, 1)\n"
     ]
    }
   ],
   "source": [
    "# normalize (scale) values between 0 and 1\n",
    "\n",
    "gdp_scaler = preprocessing.MinMaxScaler()\n",
    "\n",
    "scaled_gdp = gdp_scaler.fit_transform(df[['GDP']].values)\n",
    "\n",
    "scaled_data = pd.DataFrame(\n",
    "    np.concatenate([scaled_gdp], axis=1), \n",
    "    columns=['GDP']\n",
    "    )\n",
    "\n",
    "scaled_data.dropna(inplace=True)\n",
    "\n",
    "print(scaled_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function for processing the data to make it compatible with LSTM model\n",
    "\n",
    "def processData(data, lb, fc_out):\n",
    "\n",
    "    if isinstance(data, pd.DataFrame):\n",
    "        data = data.values\n",
    "\n",
    "    X, y = [], []\n",
    "\n",
    "    for i in range(len(data)-lb-1):\n",
    "\n",
    "        if data.shape[1] > 1:\n",
    "            X.append(data[i:(i+lb), :-1])\n",
    "\n",
    "        elif data.shape[1] == 1:\n",
    "            X.append(data[i:(i+lb), 0])\n",
    "\n",
    "        y.append(data[(i+lb):(i+lb+fc_out), 0])\n",
    "\n",
    "    X, y = np.array(X), np.array(y)\n",
    "\n",
    "    if data.shape[1] == 1:\n",
    "        X = X.reshape((X.shape[0], X.shape[1], 1))\n",
    "\n",
    "    return X, y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X: (278, 12, 1)\n",
      "y: (278, 2)\n"
     ]
    }
   ],
   "source": [
    "#process the normalized (scaled) data\n",
    "\n",
    "X, y = processData(scaled_data, LOOK_BACK, FORECAST_OUT)\n",
    "\n",
    "print(f\"X: {X.shape}\\ny: {y.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From C:\\Miniconda3\\lib\\site-packages\\tensorflow\\python\\ops\\init_ops.py:97: calling GlorotUniform.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From C:\\Miniconda3\\lib\\site-packages\\tensorflow\\python\\ops\\init_ops.py:1251: calling VarianceScaling.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From C:\\Miniconda3\\lib\\site-packages\\tensorflow\\python\\ops\\init_ops.py:97: calling Orthogonal.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From C:\\Miniconda3\\lib\\site-packages\\tensorflow\\python\\ops\\init_ops.py:97: calling Zeros.__init__ (from tensorflow.python.ops.init_ops) with dtype is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Call initializer instance with the dtype argument instead of passing it to the constructor\n",
      "WARNING:tensorflow:From C:\\Miniconda3\\lib\\site-packages\\tensorflow\\python\\ops\\math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n"
     ]
    }
   ],
   "source": [
    "# load final model that we previously trained\n",
    "model = load_model('./models/final_model.h5')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "278/278 [==============================] - 0s 1ms/sample - loss: 6.0726e-04 - mean_squared_error: 6.0726e-04 - acc: 0.7374\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[0.0006072563733239726, 0.00060725637, 0.73741007]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# evaluate model\n",
    "model.evaluate(X, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define function for predicting based on input value\n",
    "def predict(input_value):\n",
    "\n",
    "    Xt = model.predict(input_value.reshape(1, input_value.shape[0], input_value.shape[1]))\n",
    " \n",
    "    return gdp_scaler.inverse_transform(Xt)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "scaled_data = scaled_data[\"GDP\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[\"GDP\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DATE\n",
       "1947-01-01      243.164\n",
       "1947-04-01      245.968\n",
       "1947-07-01      249.585\n",
       "1947-10-01      259.745\n",
       "1948-01-01      265.742\n",
       "                ...    \n",
       "2018-07-01    20749.752\n",
       "2018-10-01    20897.804\n",
       "2019-01-01    21098.827\n",
       "2019-04-01    21340.267\n",
       "2019-07-01    21542.104\n",
       "Name: GDP, Length: 291, dtype: float64"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      0.000000\n",
       "1      0.000132\n",
       "2      0.000301\n",
       "3      0.000778\n",
       "4      0.001060\n",
       "         ...   \n",
       "286    0.962799\n",
       "287    0.969750\n",
       "288    0.979188\n",
       "289    0.990524\n",
       "290    1.000000\n",
       "Name: GDP, Length: 291, dtype: float64"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data before predicting 7 quarters into the future\n",
    "scaled_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#predict 7 quarters into the future\n",
    "\n",
    "predicted_values = gdp_scaler.transform(predict(scaled_data.values[-LOOK_BACK:].reshape(-1,1)).reshape(-1,1)).reshape(1,-1)[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[1]\n",
    "\n",
    "predicted_values = gdp_scaler.transform(predict(scaled_data.values[-LOOK_BACK:].reshape(-1,1)).reshape(-1,1)).reshape(1,-1)[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[1]\n",
    "\n",
    "predicted_values = gdp_scaler.transform(predict(scaled_data.values[-LOOK_BACK:].reshape(-1,1)).reshape(-1,1)).reshape(1,-1)[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[0]\n",
    "\n",
    "predicted_values = gdp_scaler.transform(predict(scaled_data.values[-LOOK_BACK:].reshape(-1,1)).reshape(-1,1)).reshape(1,-1)[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[0]\n",
    "\n",
    "predicted_values = gdp_scaler.transform(predict(scaled_data.values[-LOOK_BACK:].reshape(-1,1)).reshape(-1,1)).reshape(1,-1)[0]\n",
    "scaled_data[scaled_data.shape[0]] = predicted_values[0]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0      0.000000\n",
       "1      0.000132\n",
       "2      0.000301\n",
       "3      0.000778\n",
       "4      0.001060\n",
       "         ...   \n",
       "293    0.964765\n",
       "294    1.003902\n",
       "295    0.979023\n",
       "296    0.983737\n",
       "297    0.987955\n",
       "Name: GDP, Length: 298, dtype: float64"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# data before predicting 7 quarters into the future\n",
    "scaled_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# convert normalized data back into real world data\n",
    "new_data = gdp_scaler.inverse_transform(scaled_data.values.reshape(-1,1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  243.164     ],\n",
       "       [  245.968     ],\n",
       "       [  249.585     ],\n",
       "       [  259.745     ],\n",
       "       [  265.742     ],\n",
       "       [  272.567     ],\n",
       "       [  279.196     ],\n",
       "       [  280.366     ],\n",
       "       [  275.034     ],\n",
       "       [  271.351     ],\n",
       "       [  272.889     ],\n",
       "       [  270.627     ],\n",
       "       [  280.828     ],\n",
       "       [  290.383     ],\n",
       "       [  308.153     ],\n",
       "       [  319.945     ],\n",
       "       [  336.        ],\n",
       "       [  344.09      ],\n",
       "       [  351.385     ],\n",
       "       [  356.178     ],\n",
       "       [  359.82      ],\n",
       "       [  361.03      ],\n",
       "       [  367.701     ],\n",
       "       [  380.812     ],\n",
       "       [  387.98      ],\n",
       "       [  391.749     ],\n",
       "       [  391.171     ],\n",
       "       [  385.97      ],\n",
       "       [  385.345     ],\n",
       "       [  386.121     ],\n",
       "       [  390.996     ],\n",
       "       [  399.734     ],\n",
       "       [  413.073     ],\n",
       "       [  421.532     ],\n",
       "       [  430.221     ],\n",
       "       [  437.092     ],\n",
       "       [  439.746     ],\n",
       "       [  446.01      ],\n",
       "       [  451.191     ],\n",
       "       [  460.463     ],\n",
       "       [  469.779     ],\n",
       "       [  472.025     ],\n",
       "       [  479.49      ],\n",
       "       [  474.864     ],\n",
       "       [  467.54      ],\n",
       "       [  471.978     ],\n",
       "       [  485.841     ],\n",
       "       [  499.555     ],\n",
       "       [  510.33      ],\n",
       "       [  522.653     ],\n",
       "       [  525.034     ],\n",
       "       [  528.6       ],\n",
       "       [  542.648     ],\n",
       "       [  541.08      ],\n",
       "       [  545.604     ],\n",
       "       [  540.197     ],\n",
       "       [  545.018     ],\n",
       "       [  555.545     ],\n",
       "       [  567.664     ],\n",
       "       [  580.612     ],\n",
       "       [  594.013     ],\n",
       "       [  600.366     ],\n",
       "       [  609.027     ],\n",
       "       [  612.28      ],\n",
       "       [  621.672     ],\n",
       "       [  629.752     ],\n",
       "       [  644.444     ],\n",
       "       [  653.938     ],\n",
       "       [  669.822     ],\n",
       "       [  678.674     ],\n",
       "       [  692.031     ],\n",
       "       [  697.319     ],\n",
       "       [  717.79      ],\n",
       "       [  730.191     ],\n",
       "       [  749.323     ],\n",
       "       [  771.857     ],\n",
       "       [  795.734     ],\n",
       "       [  804.981     ],\n",
       "       [  819.638     ],\n",
       "       [  833.302     ],\n",
       "       [  844.17      ],\n",
       "       [  848.983     ],\n",
       "       [  865.233     ],\n",
       "       [  881.439     ],\n",
       "       [  909.387     ],\n",
       "       [  934.344     ],\n",
       "       [  950.825     ],\n",
       "       [  968.03      ],\n",
       "       [  993.337     ],\n",
       "       [ 1009.02      ],\n",
       "       [ 1029.956     ],\n",
       "       [ 1038.147     ],\n",
       "       [ 1051.2       ],\n",
       "       [ 1067.375     ],\n",
       "       [ 1086.059     ],\n",
       "       [ 1088.608     ],\n",
       "       [ 1135.156     ],\n",
       "       [ 1156.271     ],\n",
       "       [ 1177.675     ],\n",
       "       [ 1190.297     ],\n",
       "       [ 1230.609     ],\n",
       "       [ 1266.369     ],\n",
       "       [ 1290.566     ],\n",
       "       [ 1328.904     ],\n",
       "       [ 1377.49      ],\n",
       "       [ 1413.887     ],\n",
       "       [ 1433.838     ],\n",
       "       [ 1476.289     ],\n",
       "       [ 1491.209     ],\n",
       "       [ 1530.056     ],\n",
       "       [ 1560.026     ],\n",
       "       [ 1599.679     ],\n",
       "       [ 1616.116     ],\n",
       "       [ 1651.853     ],\n",
       "       [ 1709.82      ],\n",
       "       [ 1761.831     ],\n",
       "       [ 1820.487     ],\n",
       "       [ 1852.332     ],\n",
       "       [ 1886.558     ],\n",
       "       [ 1934.273     ],\n",
       "       [ 1988.648     ],\n",
       "       [ 2055.909     ],\n",
       "       [ 2118.473     ],\n",
       "       [ 2164.27      ],\n",
       "       [ 2202.76      ],\n",
       "       [ 2331.633     ],\n",
       "       [ 2395.053     ],\n",
       "       [ 2476.949     ],\n",
       "       [ 2526.61      ],\n",
       "       [ 2591.247     ],\n",
       "       [ 2667.565     ],\n",
       "       [ 2723.883     ],\n",
       "       [ 2789.842     ],\n",
       "       [ 2797.352     ],\n",
       "       [ 2856.483     ],\n",
       "       [ 2985.557     ],\n",
       "       [ 3124.206     ],\n",
       "       [ 3162.532     ],\n",
       "       [ 3260.609     ],\n",
       "       [ 3280.818     ],\n",
       "       [ 3274.302     ],\n",
       "       [ 3331.972     ],\n",
       "       [ 3366.322     ],\n",
       "       [ 3402.561     ],\n",
       "       [ 3473.413     ],\n",
       "       [ 3578.848     ],\n",
       "       [ 3689.179     ],\n",
       "       [ 3794.706     ],\n",
       "       [ 3908.054     ],\n",
       "       [ 4009.601     ],\n",
       "       [ 4084.25      ],\n",
       "       [ 4148.551     ],\n",
       "       [ 4230.168     ],\n",
       "       [ 4294.887     ],\n",
       "       [ 4386.773     ],\n",
       "       [ 4444.094     ],\n",
       "       [ 4507.894     ],\n",
       "       [ 4545.34      ],\n",
       "       [ 4607.669     ],\n",
       "       [ 4657.627     ],\n",
       "       [ 4722.156     ],\n",
       "       [ 4806.16      ],\n",
       "       [ 4884.555     ],\n",
       "       [ 5007.994     ],\n",
       "       [ 5073.372     ],\n",
       "       [ 5190.036     ],\n",
       "       [ 5282.835     ],\n",
       "       [ 5399.509     ],\n",
       "       [ 5511.253     ],\n",
       "       [ 5612.463     ],\n",
       "       [ 5695.365     ],\n",
       "       [ 5747.237     ],\n",
       "       [ 5872.701     ],\n",
       "       [ 5960.028     ],\n",
       "       [ 6015.116     ],\n",
       "       [ 6004.733     ],\n",
       "       [ 6035.178     ],\n",
       "       [ 6126.862     ],\n",
       "       [ 6205.937     ],\n",
       "       [ 6264.54      ],\n",
       "       [ 6363.102     ],\n",
       "       [ 6470.763     ],\n",
       "       [ 6566.641     ],\n",
       "       [ 6680.803     ],\n",
       "       [ 6729.459     ],\n",
       "       [ 6808.939     ],\n",
       "       [ 6882.098     ],\n",
       "       [ 7013.738     ],\n",
       "       [ 7115.652     ],\n",
       "       [ 7246.931     ],\n",
       "       [ 7331.075     ],\n",
       "       [ 7455.288     ],\n",
       "       [ 7522.289     ],\n",
       "       [ 7580.997     ],\n",
       "       [ 7683.125     ],\n",
       "       [ 7772.586     ],\n",
       "       [ 7868.468     ],\n",
       "       [ 8032.84      ],\n",
       "       [ 8131.408     ],\n",
       "       [ 8259.771     ],\n",
       "       [ 8362.655     ],\n",
       "       [ 8518.825     ],\n",
       "       [ 8662.823     ],\n",
       "       [ 8765.907     ],\n",
       "       [ 8866.48      ],\n",
       "       [ 8969.699     ],\n",
       "       [ 9121.097     ],\n",
       "       [ 9293.991     ],\n",
       "       [ 9417.264     ],\n",
       "       [ 9524.152     ],\n",
       "       [ 9681.856     ],\n",
       "       [ 9899.378     ],\n",
       "       [10002.857     ],\n",
       "       [10247.679     ],\n",
       "       [10319.825     ],\n",
       "       [10439.025     ],\n",
       "       [10472.879     ],\n",
       "       [10597.822     ],\n",
       "       [10596.294     ],\n",
       "       [10660.294     ],\n",
       "       [10788.952     ],\n",
       "       [10893.207     ],\n",
       "       [10992.051     ],\n",
       "       [11071.463     ],\n",
       "       [11183.507     ],\n",
       "       [11312.875     ],\n",
       "       [11567.326     ],\n",
       "       [11769.275     ],\n",
       "       [11920.169     ],\n",
       "       [12108.987     ],\n",
       "       [12303.34      ],\n",
       "       [12522.425     ],\n",
       "       [12761.337     ],\n",
       "       [12910.022     ],\n",
       "       [13142.873     ],\n",
       "       [13332.316     ],\n",
       "       [13603.933     ],\n",
       "       [13749.806     ],\n",
       "       [13867.469     ],\n",
       "       [14037.228     ],\n",
       "       [14208.569     ],\n",
       "       [14382.363     ],\n",
       "       [14535.003     ],\n",
       "       [14681.501     ],\n",
       "       [14651.039     ],\n",
       "       [14805.611     ],\n",
       "       [14835.187     ],\n",
       "       [14559.543     ],\n",
       "       [14394.547     ],\n",
       "       [14352.85      ],\n",
       "       [14420.312     ],\n",
       "       [14628.021     ],\n",
       "       [14721.35      ],\n",
       "       [14926.098     ],\n",
       "       [15079.917     ],\n",
       "       [15240.843     ],\n",
       "       [15285.828     ],\n",
       "       [15496.189     ],\n",
       "       [15591.85      ],\n",
       "       [15796.46      ],\n",
       "       [16019.758     ],\n",
       "       [16152.257     ],\n",
       "       [16257.151     ],\n",
       "       [16358.863     ],\n",
       "       [16569.591     ],\n",
       "       [16637.926     ],\n",
       "       [16848.748     ],\n",
       "       [17083.137     ],\n",
       "       [17104.555     ],\n",
       "       [17432.909     ],\n",
       "       [17721.657     ],\n",
       "       [17849.912     ],\n",
       "       [17984.178     ],\n",
       "       [18219.405     ],\n",
       "       [18344.713     ],\n",
       "       [18350.825     ],\n",
       "       [18424.283     ],\n",
       "       [18637.253     ],\n",
       "       [18806.743     ],\n",
       "       [18991.883     ],\n",
       "       [19190.431     ],\n",
       "       [19356.649     ],\n",
       "       [19611.704     ],\n",
       "       [19918.91      ],\n",
       "       [20163.159     ],\n",
       "       [20510.177     ],\n",
       "       [20749.752     ],\n",
       "       [20897.804     ],\n",
       "       [21098.827     ],\n",
       "       [21340.267     ],\n",
       "       [21542.104     ],\n",
       "       [20468.8160276 ],\n",
       "       [21303.55056441],\n",
       "       [20791.63991886],\n",
       "       [21625.20396215],\n",
       "       [21095.3220516 ],\n",
       "       [21195.72805249],\n",
       "       [21285.56406522]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJAAAAIDCAYAAABb8uT+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdeXiU5dn38d+dnRASEkgIkIRAQEBABQOirVUrLrV1f9pHxb0VW62tba222KdqF2v7Wlu1dWtrARGpdbcu1eKCrWtQ2UGSEJKQQAKBhBCyTHK9fxAoIssAgWvOzPdzHB7qnZnJGeebOcrZe+4JnHMCAAAAAAAAdifG9wAAAAAAAACIbCyQAAAAAAAAsEcskAAAAAAAALBHLJAAAAAAAACwRyyQAAAAAAAAsEcskAAAAAAAALBHcb4H2F99+/Z1+fn5vsc4YKFQSHFxZp8GRBFahRW0CitoFVbQKiygU1hhodV58+atc85l7nw8sqfeg/z8fBUVFfke44C1trYqISHB9xjAXtEqrKBVWEGrsIJWYQGdwgoLrQZBsGpXx3kLm2f19fW+RwDCQquwglZhBa3CClqFBXQKKyy3ygLJM8vxILrQKqygVVhBq7CCVmEBncIKy62yQAIAAAAAAMAesUDyLCsry/cIQFhoFVbQKqygVVhBq7CATmGF5VZZIHkWBIHvEYCw0CqsoFVYQauwglZhAZ3CCsutskDybO3atb5HAMJCq7CCVmEFrcIKWoUFdAorLLfKAgkAAAAAAAB7FOd7gIOpublZtbW1am5uVigU8j3OLrW3t2vp0qW+x4ho8fHxysrKUmpqqu9Rohr//WEFrcIKWoUVtAoL6BRWWG612y6Q6uvrtXbtWmVmZio7O1txcXER+V5D51xEzhUpnHPasmWLVq9eLcn2L5t1GRkZvkcAwkKrsIJWYQWtwgI6hRWWW+22b2Fbt26dcnJylJ6ervj4+Ihd0rS0tPgeIaIFQaDk5GQNHDhQNTU1vseJamVlZb5HAMJCq7CCVmEFrcICOoUVllvttguk1tZW9ejRw/cY6CI9evRQW1ub7zEAAAAAAIhK3XaBJNn4eDwLM0YC/jv5Fx8f73sEICy0CitoFVbQKiygU1hhudVuvUCyIDEx0fcIQFgGDRrkewQgLLQKK2gVVtAqLKBTWGG5VRZInnENJFixatUq3yMAYaFVWEGrsIJWYQGdwgrLrbJA8sw553sEry6//HLl5+f7HgNh4BpUsIJWYQWtwgpahQV0Cisst8oCqZt44403FASBEhIStG7duv16jI6ODt1666165plnung6AAAAAABgGQskz7rqGkgzZsxQTk6OJOmxxx7br8fo6OjQbbfdxgIJu8SZYrCCVmEFrcIKWoUFdAorLLfKAsmzUCh0wI/R1NSkJ554QldccYVOO+00zZgxowsmAz6trq7O9whAWGgVVtAqrKBVWECnsMJyqyyQPGtvbz/gx3j66ae1adMmTZ48WZMnT1ZRUZGWLFnymdutWrVKV155pQYOHKjExETl5uZq8uTJWr16tcrKyrZ/nOD06dMVBIGCINCJJ54oSZo2bZqCIFBZWdlnHjcIAt16663b/72urk433XSTxo4dq7S0NPXo0UOFhYWaNWvWAf+s8KehocH3CEBYaBVW0CqsoFVYQKewwnKrcb4HwIGbMWOGCgsLNXz4cOXl5alXr16aMWOG7rjjju23Wb58uT73uc+pqalJV111lQ4//HDV1NTohRdeUHFxsQoLCzV9+nRddtllOv744zVlyhRJUr9+/fZ5ntLSUs2aNUvnn3++rrrqKrW0tOipp57S5MmT1dbWpssuu6zLfnYAAAAAALqac06/e/UTnXFEf43ITvU9TkRggeTZtrN+9ldVVZX+9a9/6be//a0kqUePHjr33HM1c+ZM3X777YqJ2XqS2bXXXquGhga9//77Ouqoo7bf///+7//knFMQBLrooot02WWXaciQIbr44ov3e6YxY8aorKxMsbGx249df/31mjRpkn71q1+xQDJqf5aJgA+0CitoFVbQKiygU3S1yg1bdM9rxVpV16S7LxjbZY9rudWoWyDd9vxiLamKnFPGRvbvpVvPGr3f9585c6aCINAFF1yw/djkyZM1Y8YMzZkzR6eccorWrVun1157TZMnT/7U8mibIAj2+/vvyo4XBm9tbVVjY6M6Ojo0adIkTZ06VZs2bVKvXr269Hvi4HPO+R4BCAutwgpahRW0CgvoFLvT0eF0wxPzJUl3fe2zfx7enYWr6yVJry2rUWuoQwlxXXMFIMutcg0kzzraOw7o/jNmzND48ePV3NyssrIylZWVqaCgQOnp6Zo+fbokqaSkRM45HXHEEV0x8l455/T73/9eI0aMUFJSkvr06aPMzExNnTpVkrRhw4ZDMge6Vk1Nje8RgLDQKqygVVhBq7CATrE7v5+zQk99uFpzltbs0/Jm2wJpU3NI761c32XzWG416s5AuuXMUb5H+JTm5ub9vu+8efO0ePFiSdLgwYM/8/VtF9fe5kDONNrdfXd1EfA777xTN954oyZPnqybb75ZmZmZiouL04svvqjf/e536ug4sKUZAAAAAAB788KCat0zZ4X6piRqXWOL6ja3qk9K4t7vKGnR6noNzUrR6g1b9MritTp+WOZBnjbyRd0CKdLseJ2gfTV9+nQlJiZq1qxZ2691tE11dbWuueYaPfHEEzrrrLMUBIEWLFiwx8fb04IpPT1d0tazh/Lz87cfLy0t/cxtZ82apRNOOEEzZ8781PE5c+bs7UdCBEtLS/M9AhAWWoUVtAoraBUW0Cl2tmh1vX7w94919KB0Xf2FIZryyDyV1G4Oa4HknNPC1fU6fVS2hmam6JUla3TbWaMUE3Pgl3+x3CoLJM/2d4HU1tam2bNn6+STT9Z55523y9vccccdmjFjhq644gp98Ytf1OzZs3XDDTd85q1s2y6iHRsbq6SkpF2+xWzYsGGSpNdee01jx/73AmK///3vd/kz7XyWUW1trf7yl7/s88+JyGH5hQ7RhVZhBa3CClqFBXSKHW1satWUGUVKT07QAxcfrea2re+cKalt1ITBGZ+5/bY/E29TuWGLNja1afTANCUnxOrlxWu0YHW9jsrtfcCzWW6VayB51traul/3e/HFF1VbW6uzzz57t7c566yz9Oabb2rVqlW69957lZKSomOPPVbXX3+9HnroId1+++36/Oc/r7lz526/z/jx4/Wvf/1Ld955p2bPnq3XXntNkjRy5EidcMIJ+slPfqKpU6fqvvvu0znnnKP333//M9/33HPP1VtvvaULLrhADz30kG677TYdeeSRys3N3a+fFZGhvLzc9whAWGgVVtAqrKBVWECn2NFPnlmk2sYWPXjJ0crslagBvXsoMS5GpbWNn7nt/z74jn7+j6WfOrao8/pHYwam6YsjshQbE+iVxWt2+b3qm9r0qxeX6u5/rQhrNsutskAyasaMGQqCQGeeeeZub3P22WfLOadHHnlEI0eO1AcffKDzzjtPjz32mK677jo98MADGjx48PaziyTp/vvvV2FhoW655RZdeOGF+tnPfrb9a4888ogmTZqku+++WzfffLNSU1P18ssvf+b73nTTTfrpT3+qd999V9/5znc0e/ZsTZ06Vdddd13X/kcAAAAAAGAHz82v0j8WVOv6SYfpiJytZwzFxgQa3LenSmo3f+q2jS0hvV9Wpyc/rFTbDh9wtXB1veJiAg3P7qXeyQmaOCRDryxZ+6n7Nre168E3S3T8b17TQ2+VqrZx/69vbAVvYfNs52sXhevJJ5/c620mTZr0qavMFxQU6JFHHtnjfUaNGqU333xzl1/Lzc3V888//5njO1/JPi4uTrfddptuu+22z9z28ssv/9S/T5s2bY/zIHIkJoZ3sTnAN1qFFbQKK2gVFtApJGlNfbP+75lFGpvXW1d/YcinvlaQmaJFVfWfOrakqkHOSfVb2vRu6frtF8peuLpeh/XrpaT4rZecOfXwbN3y3GKV1DZqSN+eenHhGv3yhSWqqm/WScMzdePpIzSyf2pYM1pulTOQPEtISPA9AhAW3oIIK2gVVtAqrKBVWECncM7pxicXqDXUobu+dpTiYj+97ijI7KmKuia1hP77SeLb3qqWEBujlxat2f44i1bXa8zA/16r6JTD+0mSHv73Sl368Pu6dtaH6p2coMeumqi/XjEh7OWRZLtVFkietbS0+B4BCEtZWZnvEYCw0CqsoFVYQauwgE4x7e0yzf2kVlPPGKHBfXt+5utDMlPU4aRV65u2H1u0ul5ZvRJ1yuH99MriNWrvcFq9cYs2NLVpdM5/F0gDevfQETlpevS9cn1csVE/O3uUnr/u8zq2oM8+z2m5Vd7C5tnOb/8CIlUoFPI9AhAWWoUVtAoraBUW0Gl0+0/xOv3ihaWaNDJLF08ctMvbFGSmSJJKaxt1WL9ekra+VW3MwDSdPjpbLyysVlFZnTY0bf2gqx3PQJKk7006TG+tWKdvnVigzF77/zY0y62yQAIAAAAAACatXLdZ1zz6oQoye+r3F4xVEAS7vN2QzK1nJW27kHZTa0gltY06Y0x/nTQiSwlxW9/G1jMxVnExgUZk9/rU/U8akaWTRmQd3B8mwrFA8szyBbQQXQYPHux7BCAstAoraBVW0CosoNPo1NDcpm9M/0AxgfTnS8crJXH3K46eiXHKTk1SSU2jpK0X0O5wW880SkmM0xeGZeqfi9doaFaKhu1wAe2uZrlVroHkmeXT1xBdamtrfY8AhIVWYQWtwgpahQV0Gn2a29p17aMfatX6Jt1/8dHK65O81/sUZPVUybqtZyAt7LyA9pjOax19aXS2quub9XbJeo0ZGP5FsfeV5Va79QLJwvWF2tvb934jmHguu7vGxkbfIwBhoVVYQauwglZhAZ1Glw2bW3XRn97Vv4vX6fZzx2jikPAuZl2QmaLSmkY557Rwdb0yeyWqX2qSJGnSyH6KiwnU3uE+c/2jrmS51W67QIqNjVVbW5vvMdBFQqGQ4uJ4xyUAAAAARLOKuiad/8DbWlTVoPsuGqevjc8N+75D+vbUppaQaje1aFHnBbS3SUuO13FD+0qSRh/EBZJl3XaB1KtXLzU0NPgeY6/i4+N9j2DCpk2blJSU5HuMqNa/f3/fIwBhoVVYQauwglZhAZ1Gh5XrNuv8+9/Wuk0tmvn1Y/SlMfv2vBdkbf0ktkVV9SquafzMouiSiYM0IruXRvY/eG9hs9xqtz2lIyMjQ+Xl5ZKk1NRUxcfH7/Zq7D7x1qw9c85py5YtWrdunfLy8nyPE9W4XhesoFVYQauwglZhAZ12f23tHfru7I/U1t6hJ751nA7r12vvd9rJkMytC6R/LKjefgHtHZ1yeD+dcni/Lpl3dyy32m0XSImJicrLy1NdXZ3Kysoi9lpDbW1tnIW0F4mJierXrx9nIHlWW1urtDRO5UTko1VYQauwglZhAZ12f/e+VqwFlfV64OJx+7U8kqT+qUnqER+rfy5aI+mzC6RDwXKr3XaBJG1dPPTv3z+iTxErLi7W0KFDfY8BAAAAAEBE+qh8g/74erHOGzdQp4/e/z/fx8QEGpLZU4urGtQ3JVH9UhO7cMrur9teA8mK9PR03yMAYaFVWEGrsIJWYQWtwgI67b6aWkP6/uPzlZ2apFvPGnXAj7ftbWyjB6Z6ucyN5Va79RlIFqSkpPgeAQgLrcIKWoUVtAoraBUW0Gn39ZuXl6ts/WbN+sZEpSYd+OVfCjJ7SvLz9jXJdqucgeRZRUWF7xGAsNAqrKBVWEGrsIJWYQGddk9VG7fo0fdW6cIJeTq2oE+XPGbB9jOQ/CyQLLfKAgkAAAAAAESch+aWyjnp2pO67rrBJ4/M0vcmHaYTDsvssseMFryFzTM+WQxW0CqsoFVYQauwglZhAZ12P+saWzT7g3KdO3agBvbu0WWPm5wQp+9OGtZlj7evLLfKGUie5eTk+B4BCAutwgpahRW0CitoFRbQaffz8L9XqiXUoW+eWOB7lC5luVUWSJ6Vlpb6HgEIC63CClqFFbQKK2gVFtBp91K/pU2PvLNKZ4zpv/2aRd2F5VZZIHnW0dHhewQgLLQKK2gVVtAqrKBVWECn3csj75RpU0tI13Szs48k262yQAIAAAAAABFhc0tID/+nTF8ckaVRA/x8Uhp2ba8LpCAIcoMgeD0IgqVBECwOguC7ncczgiB4NQiCFZ1/T+88HgRBcE8QBMVBECwIgmDcDo91WeftVwRBcNkOx48OgmBh533uCYIgOBg/bCQqKOh+G1V0T7QKK2gVVtAqrKBVWECn3cevXlqqDU2t+s7J/i50fTBZbjWcM5BCkn7gnBspaaKka4MgOFzSjyTNcc4NkzSn898l6UuShnX+NUXS/dLWhZOkWyQdI2mCpFu2LZ06bzNlh/udfuA/mg1r1qzxPQIQFlqFFbQKK2gVVtAqLKDT7mHuJ7Wa+W65vvH5wToqt7fvcQ4Ky63udYHknKt2zn3Y+c+bJC2VNFDS2ZKmd95suqRzOv/5bEkz3FbvSuodBEF/SadJetU5V+ec2yDpVUmnd34t1Tn3jnPOSZqxw2N1e5s3b/Y9AhAWWoUVtAoraBVW0CosoFP76re06aYnF2hoVop+cOpw3+McNJZbjduXGwdBkC9prKT3JPVzzlVLW5dMQRBkdd5soKSKHe5W2XlsT8crd3F8V99/iraeqaScnBwVFxdLkvr06aPExERVVVVJknr27Kns7GyVlJRIkmJiYjRkyBBVVlaqublZkpSbm6vGxkZt2LBBkpSZmam4uDhVV1dLklJSUpSZmamVK1dKkuLi4pSfn6+Kigq1tLRIkvLy8lRfX6/6+npJUlZWloIg0Nq1ayVJqampysjIUFlZmSQpPj5egwYN0qpVq9TW1qbO/3aqqalRQ0ODJKlfv37bj0lSWlqa0tLSVF5eLklKTExUbm6uysrKFAqFJEmDBw9WbW2tGhsbJUn9+/dXKBRSbW2tJCk9PV0pKSmqqNj6nz8pKUk5OTkqLS3dfgGvgoICrVmzZnvMAwYMUEtLi9avXy9JysjIUHJysiortz5VycnJGjBggEpKSuScUxAEKigoUFVVlZqamrTtOWpqalJdXZ355yk/P191dXVR/Ty1tLSouLiY5ynCnyd+n2q3/7fmeYrs50ni98k5p9raWp6nCH+e+H0asP1/A/A8RfbzFO2/T9s65XmK7OdpT79Pv3tnvdY2NOveswapctXKbvs8tbS0qKWlJaKfp90J9vTFT90wCFIkvSnpl865p4Ig2Oic673D1zc459KDIHhB0q+cc//uPD5H0o2Svigp0Tn3i87j/yepSdLczttP6jx+vKQbnXNn7mmewsJCV1RUFNbskaypqUnJycm+xwD2ilZhBa3CClqFFbQKC+jUtlcWr9GUR+bpOycP0/dPOcz3OAeVhVaDIJjnnCvc+XhYn8IWBEG8pCclPeqce6rz8NrOt5+p8+81nccrJeXucPccSVV7OZ6zi+NRYdv2EIh0tAoraBVW0CqsoFVYQKd2tYY69PMXlmhEdi99+6Shvsc56Cy3Gs6nsAWS/iJpqXPurh2+9JykbZ+kdpmkZ3c4fmnnp7FNlFTf+Va3f0o6NQiC9M6LZ58q6Z+dX9sUBMHEzu916Q6P1e1tO3UOiHS0CitoFVbQKqygVVhAp3Y9+t4qVdRt0Y/PGKmEuLDOcTHNcqvhXAPpc5IukbQwCIKPO49NlXSHpMeDIPi6pHJJX+382ouSzpBUrK1vUbtCkpxzdUEQ/FzSB523+5lzrq7zn78laZqkHpJe6vwLAAAAAAB0U5ua23Tva8U6rqCPvjCsr+9xsBd7XSB1Xsso2M2XT97F7Z2ka3fzWA9LengXx4skjd7bLN1RRkaG7xGAsNAqrKBVWEGrsIJWYQGd2vTQ3FLVbW7Vj740QlvfkNT9WW61+58fFuEi/eJZwDa0CitoFVbQKqygVVhAp/bUNDTrz2+t1FeO6K8jcnrv/Q7dhOVWWSB5tu3jAoFIR6uwglZhBa3CClqFBXRqz91zVqitvUM3nDrc9yiHlOVWWSABAAAAAIBDZtHqes3+oEIXHZOn/L49fY+DMLFA8szy6WuILrQKK2gVVtAqrKBVWECndrS1d+jGJxYoo2eCfnBKdJ19JNluNZxPYcNBNGDAAN8jAGGhVVhBq7CCVmEFrcICOrXjwTdLtKS6QQ9cfLTSkuN9j3PIWW6VM5A8Kykp8T0CEBZahRW0CitoFVbQKiygUxuKazbpnjnF+vKY/jp9dLbvcbyw3CoLJM+cc75HAMJCq7CCVmEFrcIKWoUFdBr52jucbnxigZITY3XrWaN8j+ON5VZZIHkWBIHvEYCw0CqsoFVYQauwglZhAZ1GNuec7nxluT4s36iffuVwZfZK9D2SN5ZbDaxuvwoLC11RUZHvMQAAAAAAwG445/TbVz7RH14v1oUT8nT7uaNNL1GiQRAE85xzhTsf5wwkz6qqqnyPAISFVmEFrcIKWoUVtAoL6DQyfXp5lKtfnsPyyHKrLJA8a2pq8j0CEBZahRW0CitoFVbQKiyg08j0u3+t2GF5NEYxMdG9PJJst8oCCQAAAAAAdKnHiyp0z5wV+lphDsujboIFkmc5OTm+RwDCQquwglZhBa3CClqFBXQaWd5fWaebn16ozw/tq1+ey/JoR5ZbZYHkmeXT1xBdaBVW0CqsoFVYQauwgE4jR/n6Jl39SJFy05P1x4vGKT6WtcOOLLfKM+lZXV2d7xGAsNAqrKBVWEGrsIJWYQGdRoaG5jZ9ffoH6nDSXy4fr7TkeN8jRRzLrbJAAgAAAAAAB6Ql1K4pM4q0ct1m3T95nAb37el7JHSxON8DRLs+ffr4HgEIC63CClqFFbQKK2gVFtCpXx0dTt9/fL7eLa3T7/73SB03tK/vkSKW5VY5A8mzxMRE3yMAYaFVWEGrsIJWYQWtwgI69cc5p5+/sEQvLKjWj780QueOtXuR6EPBcqsskDyrqqryPQIQFlqFFbQKK2gVVtAqLKBTfx54s1R//U+ZrvzcYE35whDf40Q8y62yQAIAAAAAAPvsL/9eqV+/vExnHTlAP/nySAVB4HskHEQskDzr2ZMLi8EGWoUVtAoraBVW0CosoNNDb8Y7Zfr5P5boS6OzddfXjlRMDMujcFhuNXDO+Z5hvxQWFrqioiLfYxww5xxbWphAq7CCVmEFrcIKWoUFdHpozXqvXFOfXqhTDu+n+yaPU3ws56aEy0KrQRDMc84V7nycZ9mzkpIS3yMAYaFVWEGrsIJWYQWtwgI6PXReX1ajm59ZqC+OyNIfLhrL8mgfWW6VZxoAAAAAAOxV+fomfXf2RxqZnar7Jo9TYlys75FwCLFA8iwmhqcANtAqrKBVWEGrsIJWYQGdHnzNbe365sx5kqQHLj5aSfEsj/aH5Va5BhIAAAAAANgt55xu+PsCPflhpf56+XidNCLL90g4iLgGUoSqrKz0PQIQFlqFFbQKK2gVVtAqLKDTg6e4plE3PrF1efSdk4exPDpAlluN8z1AtGtubvY9AhAWWoUVtAoraBVW0CosoNMD19HhtKS6QZuaQ2pua1dDc5ue+Wi1Xl9eq4S4GF1+XL6+e/Iw32OaZ7lVFkgAAAAAAESxus2t+t7fPtabn9R+6njflAR9b9JhmjwxT31TEj1Nh0jBAsmz3Nxc3yMAYaFVWEGrsIJWYQWtwgI63X9FZXW67rGPtL6xVTefMVKjB6apR0KskuJjNLhvTz5prYtZbpUFkmeNjY1KTGSTi8hHq7CCVmEFrcIKWoUFdLp/Zr67Src8t1g56T301DXHafTANN8jdXuWW+Ui2p5t2LDB9whAWGgVVtAqrKBVWEGrsIBO9928VRt0y3OL9YVhffX8dZ9neXSIWG6VBRIAAAAAAFGksSWk7/3tY2WnJunuC8cqNSne90gwgLeweZaZmel7BCAstAoraBVW0CqsoFVYQKf75rbnFqtyQ5NmTzmW5dEhZrlVzkDyLC6OHR5soFVYQauwglZhBa3CAjoN30sLq/X3eZX61okFmjA4w/c4UcdyqyyQPKuurvY9AhAWWoUVtAoraBVW0CosoNPwLFpdrx8/vVBH5KTp+kmH+R4nKllulQUSAAAAAADd3JPzKnX+/W+rR3ys7r5grOJjWQdg39g9d6qbSElJ8T0CEBZahRW0CitoFVbQKiyg091rDXXoFy8s0Yx3VunYIX1070Vj1TfF5sfIdweWW2WB5JnlC2ghutAqrKBVWEGrsIJWYQGd7lpNQ7OuefRDFa3aoClfGKIbTxuuOM488spyq5Tj2cqVK32PAISFVmEFrcIKWoUVtAoL6PSzisrq9OV7/63FVQ2698KxmnrGSJZHEcByq5yBBAAAAABAN/Loe6t0y7OLlZPeQzO/foyGZ/fyPRK6ARZInln+CD9EF1qFFbQKK2gVVtAqLKDT//qwfINufnqRThyeqbsvGKu0HvG+R8IOLLcaOOd8z7BfCgsLXVFRke8xAAAAAACICB0dTufe/7aqN27RazecqJREu8sK+BMEwTznXOHOx3kDpGcVFRW+RwDCQquwglZhBa3CClqFBXS61TMfr9b8io268fQRLI8ilOVWWSB51tLS4nsEICy0CitoFVbQKqygVVhAp9LmlpB+/fIyHZmTpvPGDvQ9DnbDcqsskAAAAAAAMO6BN0u0tqFFPz1zlGJiAt/joBtigeRZXl6e7xGAsNAqrKBVWEGrsIJWYUG0d1q5oUkPzS3V2UcN0NGD0n2Pgz2w3CoLJM/q6+t9jwCEhVZhBa3CClqFFbQKC6K909+9ukKSdNPpIzxPgr2x3CoLJM8sx4PoQquwglZhBa3CClqFBdHc6cp1m/X0R5W6ZOIgDejdw/c42AvLrbJAAgAAAADAqHvmrFBCXIyuPqHA9yjo5lggeZaVleV7BCAstAoraBVW0CqsoFVYEK2dFtc06tmPV+vSY/OV2SvR9zgIg+VWWSB5FgRcHR820CqsoFVYQauwglZhQbR2es+cFUqKj9XVXxjiexSEyXKrLJA8W7t2re8RgLDQKiWH+24AACAASURBVKygVVhBq7CCVmFBNHa6Yu0mPb+gSpcem68+KZx9ZIXlVuN8DwAAAAAAAPbMOacPyjZoRc0mldc1ae4n65QcH6spnH2EQ4QFkmepqam+RwDCQquwglZhBa3CClqFBdHQ6cP/KdPP/7FEkhQfG2hg7x665axRyuiZ4Hky7AvLrbJA8iwjI8P3CEBYaBVW0CqsoFVYQauwoLt3urS6Qb9+aZkmjczSz84erX6pSYqNsXstnWhmuVWugeRZWVmZ7xGAsNAqrKBVWEGrsIJWYUF37rS5rV3Xz/5Yacnx+vX5R2hA7x4sjwyz3CpnIAEAAAAAEKHueGmZlq/dpGlXjOdi2fCKM5A8i4+P9z0CEBZahRW0CitoFVbQKizorp2+sbxG094u0+XH5evE4Vm+x0EXsNxq4JzzPcN+KSwsdEVFRb7HAAAAAACgy63euEVn3vtvZaYk6tlvf05J8bG+R0KUCIJgnnOucOfjnIHk2apVq3yPAISFVmEFrcIKWoUVtAoLulunzW3t+tbMeWoLdei+i8exPOpGLLfKNZA8a2tr8z0CEBZahRW0CitoFVbQKizobp3e8uxiLais10OXHK2CzBTf46ALWW6VM5AAAAAAAIgQj71frr8VVejbJw3VqaOyfY8DbMc1kDwLhUKKi+NEMEQ+WoUVtAoraBVW0CossN5pR4fT3BW1mvnuKr22rEafH5apv14+XrExge/R0MUstMo1kCJUXV2d7xGAsNAqrKBVWEGrsIJWYYHlTt8uXqcT73xDl//1A31csVHfOrFAf7xoLMujbspyqyyQPGtoaPA9AhAWWoUVtAoraBVW0CossNpp2brN+ubMeYqLDXTPhWP19o9O1g9PG6FeSXY/6h17ZrVViYtoAwAAAABwyDW1hvTNmfMUBIGmXzFBuRnJvkcC9ogFkmf9+vXzPQIQFlqFFbQKK2gVVtAqLLDWqXNOP3pyoZav3aRpLI+iirVWd8Rb2DyzehFzRB9ahRW0CitoFVbQKiyw1umf31qp5+ZX6YZTh+uEwzJ9j4NDyFqrO2KB5FlNTY3vEYCw0CqsoFVYQauwglZhgZVOqzZu0ZQZRfrli0t12qh++tYJBb5HwiFmpdVd4S1sAAAAAAAcRKH2Dk1/Z5XuemW52p3TjacP1zc+P0QxfNIaDGGB5FlaWprvEYCw0CqsoFVYQauwglZhQSR3uqByo3781EItrmrQicMz9fOzR3PNoygWya3uDQskzyzHg+hCq7CCVmEFrcIKWoUFkdjppuY2/faVTzTjnTL1TUnUHy8apzPGZCsIOOsomkViq+HiGkielZeX+x4BCAutwgpahRW0CitoFRZEWqdLqhp0xj1vafo7Zbpk4iD96wcn6MtH9Gd5hIhrdV9wBhIAAAAAAF3kuflVuvGJ+UrrEa8nvnmsjh6U4XskoEuwQPIsMTHR9whAWGgVVtAqrKBVWEGrsCASOu3ocLrj5WV6aG6pxuen64+TxymrV5LvsRBhIqHV/RU453zPsF8KCwtdUVGR7zEAAAAAAND9b5To1y8v08UT8/TTr4xSQhxXjIFNQRDMc84V7nycoj0rKyvzPQIQFlqFFbQKK2gVVtAqLPDd6bxVdbrzleX68pj++vnZo1keYbd8t3ogqNqzUCjkewQgLLQKK2gVVtAqrKBVWOCz041Nrbpu1kca2LuHfnX+GC6UjT2y/JrKNZAAAAAAANgPzjnd8PcFqm1s0ZPfOk6pSfG+RwIOGs5A8mzw4MG+RwDCQquwglZhBa3CClqFBb46/cu/V+pfS9dq6hkjdUROby8zwBbLr6kskDyrra31PQIQFlqFFbQKK2gVVtAqLPDR6b9XrNPtLy7V6aOydflx+Yf8+8Mmy6+pLJA8a2xs9D0CEBZahRW0CitoFVbQKiw41J2uWr9Z1876UMOyeum3XzuS6x4hbJZfU1kgAQAAAAAQpsaWkK6aUaQgkP50aaF6JnJpYUQHSvesf//+vkcAwkKrsIJWYQWtwgpahQWHqtONTa36/uPzVVK7WTOunKC8PsmH5Pui+7D8msoCyTPLH+GH6EKrsIJWYQWtwgpahQUHu9NQe4dmvV+uu179RA1b2nTbWaP0uaF9D+r3RPdk+TWVt7B5ZvkCWogutAoraBVW0CqsoFVYcDA7XbF2k8645y399NnFOrx/ql74zvG65Nj8g/b90L1Zfk3lDCQAAAAAAHahvqlN35hRpM0t7XrwkqN16uH9uGA2ohYLJM/S09N9jwCEhVZhBa3CClqFFbQKCw5Gpx0dTtf/7SNVbdyi2VOO1dGD+F3AgbP8mspb2DxLSUnxPQIQFlqFFbQKK2gVVtAqLDgYnd49Z4VeX16rn545iuURuozl11QWSJ5VVFT4HgEIC63CClqFFbQKK2gVFnRlp6H2Dj378WrdPWeF/ufoHF18TF6XPTZg+TWVt7ABAAAAAKJaW3uHnpxXqTeW1+rtknVqaA5p9MBU/eKc0VzzCOjEAsmzpKQk3yMAYaFVWEGrsIJWYQWtwoID6bS5rV3XPvqh5iyr0cDePfSl0f11/GF9ddLwLCXFx3bhlIDt19TAObfnGwTBw5K+IqnGOTe689itkq6StO3z56Y6517s/NqPJX1dUruk7zjn/tl5/HRJd0uKlfRn59wdnccHS5otKUPSh5Iucc617m3wwsJCV1RUtE8/LAAAAAAA22xuCemqGUV6p3S9fnb2aF18TB5nHCHqBUEwzzlXuPPxcK6BNE3S6bs4/jvn3FGdf21bHh0u6QJJozrvc18QBLFBEMRK+qOkL0k6XNKFnbeVpF93PtYwSRu0dfkUNUpLS32PAISFVmEFrcIKWoUVtAoL9qfT+qY2XfyX9/Teyjrd9bUjdcnEQSyPcNBZfk3d6wLJOTdXUl2Yj3e2pNnOuRbn3EpJxZImdP5V7Jwr7Ty7aLaks4Otv51flPRE5/2nSzpnH38G0zo6OnyPAISFVmEFrcIKWoUVtAoL9rXTdY0tuvBP72rR6nr98aJxOndszkGaDPg0y6+pB/IpbN8OgmBBEAQPB0Gw7TMNB0ra8ZLilZ3Hdne8j6SNzrnQTscBAAAAAOhy1fVb9L8PvqPSdY3682XjdfrobN8jASbs70W075f0c0mu8++/lXSlpF2d7+e060WV28PtdykIgimSpkhSTk6OiouLJUl9+vRRYmKiqqqqJEk9e/ZUdna2SkpKJEkxMTEaMmSIKisr1dzcLEnKzc1VY2OjNmzYIEnKzMxUXFycqqurJUkpKSnKzMzUypUrJUlxcXHKz89XRUWFWlpaJEl5eXmqr69XfX29JCkrK0tBEGjt2rWSpNTUVGVkZKisrEySFB8fr0GDBmnVqlVqa2uTJA0aNEg1NTVqaGiQJPXr10/OOdXU1EiS0tLSlJaWpvLycklSYmKicnNzVVZWplBo695t8ODBqq2tVWNjoySpf//+CoVCqq3deomq9PR0paSkbP+4wKSkJOXk5Ki0tHT79rOgoEBr1qzR5s2bJUkDBgxQS0uL1q9fL0nKyMhQcnKyKisrJUnJyckaMGCASkpK5JxTEAQqKChQVVWVmpqatO05ampqUl1dnfnnKT8/X3V1dVH9PElScXExz1OEP0/8Pm19ntavX8/zZOB54vcpT7W1tTxPBp6naP99CoJAxcXFPE8R/jxF+++TtPV/q+7teapqaNXUV9eobnOLfnXaQA2Mqdfmzck8T/w+HdLnqaWlJaKfp93Z60W0JSkIgnxJ/9h2Ee3dfa3zAtpyzv2q82v/lHRr501vdc6d1nn8x53H7tDWC3FnO+dCQRAcu+Pt9qS7XES7urpa/fv39z0GsFe0CitoFVbQKqygVVgQTqdVG7fo3Pv+o5ZQh2ZcOUFH5PQ+RNMB/2XhNfVALqK9qwfb8ac9V9Kizn9+TtIFQRAkdn662jBJ70v6QNKwIAgGB0GQoK0X2n7Obd1evS7pfzrvf5mkZ/dnJqu2bUKBSEersIJWYQWtwgpaxaEUzgkOu7K3Tpvb2nX1I/O0uaVdj101keURvLH8mrrXt7AFQfCYpBMl9Q2CoFLSLZJODILgKG19u1mZpKslyTm3OAiCxyUtkRSSdK1zrr3zcb4t6Z+SYiU97Jxb3PktbpI0OwiCX0j6SNJfuuynAwAAAABErA2bW/W3ogotrW7QsupNKl3XqOsnHaZrTxraZd/DOacfPblAC1fX60+XFmpk/9Que2wgmoT1FrZI1F3ewtbU1KTk5GTfYwB7RauwglZhBa3CClrFwVK1cYsu+ct7KqndrIG9e2h4di/VbW7VkuoGvfq9L2hQn55hP9aeOn1oboluf3GZfnDKYbru5GFdNT6wXyy8pnbpW9jQdbZdAAuIdLQKK2gVVtAqrKBVHAyltY366gPvqKahRX+bMlH/+dEX9fDl4/XgJUcrITZGtzy3eJ/ezrarTts7nB59b5XueGmZzhiTrW9/sevOagL2l+XX1P39FDZ0kfXr1ys9Pd33GMBe0SqsoFVYQauwglZxoN4uWac7XlqmPj0TNLJ/qvIyknXnK8vlnPTYlIkaPTBt+237pSbp+knD9IsXlurVJWt16qjssL7Hzp3+p3idfvHCUi2tbtCEwRn6f/9zpIJgVx8CDhxall9TWSABAAAAAA6Kfyyo0vf/Nl9ZqYlqaevQWyvWKdThNCAtSY984xgVZKZ85j6XHZevvxdV6rbnl+j4YZnqkRAb9vcLtXfoe4/P1/Pzq5ST3kP3XjhWXzmiP8sjoAuwQPIsIyPD9whAWGgVVtAqrKBVWEGr2F/T/rNSt/1jiQoHpetPlxaqd3KCWkLtKq3drJz0HuqVFL/L+8XHxuhnZ4/S/z70rv7w+gr98LQRe/1e2zr9zT+X6/n5VfrOycN0zYkFSooPf/kEHAqWX1NZIHkW6RfPArahVVhBq7CCVmEFrWJfOef0m38u1/1vlOiUw/vp3gvHbl/kJMbFhvUpaMcM6aPzxg7UfW+UaEjfFJ1/dM4eb5+cnKxnP16th+aW6tJjB+n7pxzWJT8L0NUsv6ZyEW3PKisrfY8AhIVWYQWtwgpahRW0in3R1t6hG/6+QPe/UaILJ+Tp/snj9vssoF+eO0bHFfTRDU/M1xPz9tzhG/OLddOTCzQ+P10/+fLh+/X9gEPB8msqCyQAAAAAwAFrag3pqhlFevLDSl0/aZhuP3e04mL3/4+cPRJi9edLx+tzBX31wyfm6/Giil3ebnFVvW59tUq9eyTovslHKyGOP+YCBwNvYfPM8ulriC60CitoFVbQKqygVYSjfkubLnv4fS2o3Khfnjtak48Z1CWP2yMhVn++rFBXzSjSTU8u0N8+qNDEIRmaOKSPquub9eh75ZpfsVHJ8TF69KrxyuyV2CXfFzhYLL+mBs453zPsl8LCQldUVOR7DAAAAACIao0tIV3yl/e0aHW97r1wnE4fnd3l36O5rV33vV6suSvWaeHqerV3bP1z7NCsFE0+Jk/njc1RWvKuL8oNYN8EQTDPOVf4meMskPwqKSlRQUGB7zGAvaJVWEGrsIJWYQWtYk+aWkO6/OEPNK98g/540cFZHu2ssSWkeas2qGdCrI4elK4gCOgUZlhodXcLJN7C5pnVBR6iD63CClqFFbQKK2gVu9Pc1q4pM+apaFWd7r5g7CFZHklSSmKcTjgs81PH6BRWWG6VBZJnQRD4HgEIC63CClqFFbQKK2gVu9Ia6tC3Zs7Tv4vX6c6vHqkzjxzgdR46hRWWW+UtbAAAAACAsLW1d+jbsz7UPxev1e3njtFFx+T5HglAF9rdW9j4fEPPqqqqfI8AhIVWYQWtwgpahRW0ih21dzh9//H5+ufitbrlzMMjZnlEp7DCcqsskDxramryPQIQFlqFFbQKK2gVVtAqtunocLrxiQV6fn6VfvylEbric4N9j7QdncIKy62yQAIAAAAA7JFzTjc/s0hPflip7006TFefENmfIgWg67FA8iwnJ8f3CEBYaBVW0CqsoFVYQatwzum255fosffLdc2JBfrOyUN9j/QZdAorLLfKAskzy6evIbrQKqygVVhBq7CCVqObc053vLxM094u09c/P1g/PG14RH6KFJ3CCsutskDyrK6uzvcIQFhoFVbQKqygVVhBq9Grfkubrv/bx3rwzVJdPDFPP/nyyIhcHkl0CjsstxrnewAAAAAAQGR5r3S9vv/4fK1paNb3TzlM3z5paMQujwAcGiyQPOvTp4/vEYCw0CqsoFVYQauwglaji3NO98wp1u/nfKK8jGQ98c1jNTYv3fdYe0WnsMJyqyyQPEtMTPQ9AhAWWoUVtAoraBVW0Gr0aA116EdPLtBTH63WeWMH6mfnjFZKoo0/MtIprLDcKtdA8qyqqsr3CEBYaBVW0CqsoFVYQavRoaG5TVdMe19PfbRa3z/lMP32a0eaWR5JdAo7LLdq5xUBAAAAANDlGprb9LUH3lFxTaPu/OqR+p+j7X7MOICDhwWSZz179vQ9AhAWWoUVtAoraBVW0Gr3d9crn2j52k366+XjdeLwLN/j7Bc6hRWWW+UtbJ5lZ2f7HgEIC63CClqFFbQKK2i1e1u0ul4z3inTxccMMrs8kugUdlhulQWSZyUlJb5HAMJCq7CCVmEFrcIKWu2+Ojqcbn5mkTJ6JuiG04b7HueA0CmssNwqCyQAAAAAiEKPfVCu+RUbdfOXRyqtR7zvcQBEOBZInsXE8BTABlqFFbQKK2gVVtBq97SusUW/eXm5Jg7J0DlHDfQ9zgGjU1hhudXAOed7hv1SWFjoioqKfI8BAAAAAKaE2js05ZF5emtFrV767vEamtXL90gAIkgQBPOcc4U7H7e7+uomKisrfY8AhIVWYQWtwgpahRW02r0453Tr84v12rIa/fTMUd1meUSnsMJyqyyQPGtubvY9AhAWWoUVtAoraBVW0Gr38uDcUs18t1xXnzBEl0wc5HucLkOnsMJyqyyQAAAAACAKPDe/Sne8tExnHjlAN502wvc4AIxhgeRZbm6u7xGAsNAqrKBVWEGrsIJWu4dlaxp0w9/na0J+hu786hGKiQl8j9Sl6BRWWG6VBZJnjY2NvkcAwkKrsIJWYQWtwgpata+5rV3ffexjpSbF676LxykxLtb3SF2OTmGF5VZZIHm2YcMG3yMAYaFVWEGrsIJWYQWt2nfHS8u0fO0m3fnVI9Q3JdH3OAcFncIKy62yQAIAAACAbur1ZTWa9naZrvhcvk4cnuV7HACGsUDyLDMz0/cIQFhoFVbQKqygVVhBq3bVNDTrh0/M14jsXrrp9O590Ww6hRWWW2WB5FlcXJzvEYCw0CqsoFVYQauwglZtWrV+s7724DtqbAnp7gvGKim++133aEd0Cisst8oCybPq6mrfIwBhoVVYQauwglZhBa3as7CyXuff/7Y2bmnTo9+YqOHZvXyPdNDRKayw3Krd1RcAAAAA4FPeWlGrqx+Zp/TkBM2+coKGZqX4HglAN8ECybOUFF7QYQOtwgpahRW0Cito1Y6KuiZ985F5ystI1vQrJ6hfapLvkQ4ZOoUVllvlLWyeWb6AFqILrcIKWoUVtAoraNWG9g6n7z/+sWKCQH++rDCqlkcSncIOy62yQPJs5cqVvkcAwkKrsIJWYQWtwgpateGhuaX6oGyDbjt7lHLSk32Pc8jRKayw3CoLJAAAAAAwbHFVve56dbnOGJOtc8cO9D0OgG6KBZJnlj/CD9GFVmEFrcIKWoUVtBrZmtva9b2/faz05AT98pwxCoLA90he0CmssNxq4JzzPcN+KSwsdEVFRb7HAAAAAABvpj69ULPeK9e0K8brxOFZvscB0A0EQTDPOVe483HOQPKsoqLC9whAWGgVVtAqrKBVWEGrkeuZj1Zr1nvluvqEIVG/PKJTWGG5VRZInrW0tPgeAQgLrcIKWoUVtAoraDUyFdds0tSnF2pCfoZ+eOpw3+N4R6ewwnKrLJAAAAAAwJCm1pCuefRD9YiP1T0XjlVcLH+sA3Dw2b16UzeRl5fnewQgLLQKK2gVVtAqrKDVyOKc04+eXKgVNY2aceUEZacl+R4pItAprLDcKqtqz+rr632PAISFVmEFrcIKWoUVtBpZ7nr1Ez03v0o3nDpcxw/L9D1OxKBTWGG5VRZInlmOB9GFVmEFrcIKWoUVtBo5Hv+gQve+VqwLxufqmhMLfI8TUegUVlhulQUSAAAAAES4t1bUaurTC3X8sL76+TmjFQSB75EARBkWSJ5lZUX3x23CDlqFFbQKK2gVVtCqf8vWNOiamR9qaFaK7ps8TvFcNPsz6BRWWG6VVx7P+H8OYAWtwgpahRW0Cito1a+1Dc268q8fKDkxVg9fPl69kuJ9jxSR6BRWWG6VBZJna9eu9T0CEBZahRW0CitoFVbQqj+bW0K6ctoHqt/SpocvH68BvXv4Hili0SmssNxqnO8BAAAAAACfFmrv0HWPfaRlazbpz5cVatSANN8jAYhynIHkWWpqqu8RgLDQKqygVVhBq7CCVg+91lCHfvD3+XptWY1+dvYonTTc7jVTDhU6hRWWW+UMJM8yMjJ8jwCEhVZhBa3CClqFFbR6aG1uCembM+fprRXrdNPpIzT5mEG+RzKBTmGF5VY5A8mzsrIy3yMAYaFVWEGrsIJWYQWtHjrrG1t00Z/e1X+K1+k35x+hb51Y4HskM+gUVlhulTOQAAAAAMCzhuY2XfDQuyqva9KDlxTqlMP7+R4JAD6FBZJn8fF8DCdsoFVYQauwglZhBa0efO0dTtfN+kgr123WjCsn6LihfX2PZA6dwgrLrQbOOd8z7JfCwkJXVFTkewwAAAAAOCC3v7hUD80t1S/PHc01jwB4FwTBPOdc4c7HuQaSZ6tWrfI9AhAWWoUVtAoraBVW0OrB9cS8Sj00t1SXHjuI5dEBoFNYYblVFkietbW1+R4BCAutwgpahRW0Cito9eBZtLpeU59aqOMK+uj/vnK473FMo1NYYblVFkgAAAAAcIi1hjp0w9/nK71nvP540TjFx/JHMwCRjYtoe5afn+97BCAstAoraBVW0CqsoNWD4/43SrRszSb96dJCpfdM8D2OeXQKKyy3yprbs7q6Ot8jAGGhVVhBq7CCVmEFrXa95Ws26Q+vr9BZRw7QKYf38z1Ot0CnsMJyqyyQPGtoaPA9AhAWWoUVtAoraBVW0GrXau9wuvHJBeqVFK9bzuS6R12FTmGF5VZ5CxsAAAAAHALOOf3htWLNr9ioey4cqz4pib5HAoCwsUDyrF8/TlmFDbQKK2gVVtAqrKDVrtHc1q6fPrtIjxdV6itH9NeZR/T3PVK3QqewwnKrLJA8c875HgEIC63CClqFFbQKK2j1wFXUNembM+dpcVWDrvviUF0/6TAFQeB7rG6FTmGF5Va5BpJnNTU1vkcAwkKrsIJWYQWtwgpa3X/OOT03v0pfufffKq9r0p8vLdQPTh2u2BiWR12NTmGF5VY5AwkAAAAAutj6xhb95JlFemnRGh2V21t3X3CUBvXp6XssANhvLJA8S0tL8z0CEBZahRW0CitoFVbQ6r5pDXXo6Y8q9ZuXl2tTc0g3nT5CVx0/WHGxvPnjYKJTWGG5VRZInlmOB9GFVmEFrcIKWoUVtBqeLa3tmv1BuR6aW6rq+mYdmdtbvzn/CA3P7uV7tKhAp7DCcquswT0rLy/3PQIQFlqFFbQKK2gVVtDqnjnn9OzHq/WF//e6bnt+iXLTkzXtivF65prjWB4dQnQKKyy3yhlIAAAAALAfimsa9dNnF+ntkvU6IidNf7hwrI4Z0sf3WABwULBA8iwxMdH3CEBYaBVW0CqsoFVYQauftaW1XX94fYUemluqpPhY/fyc0bpoQh6fruYRncIKy60GzjnfM+yXwsJCV1RU5HsMAAAAAFFkztK1uuW5xarcsEXnjR2oH58xUpm97P6BEAB2FgTBPOdc4c7HuQaSZ2VlZb5HAMJCq7CCVmEFrcIKWt1qU3Obrp31ob4+vUhJ8bF67KqJuut/j2J5FCHoFFZYbpW3sHkWCoV8jwCEhVZhBa3CClqFFbQqLV+zSd+cOU/ldU264dTDNOULBUqI4/+LjyR0Cisst8oCCQAAAAB2wTmnZz5eralPLVJKUpweu2qiJgzO8D0WAHjBNZA8a29vV2xsrO8xgL2iVVhBq7CCVmFFNLa6rrFFT3+4Wo8XVWhFTaMmDM7QHy4aq6xeSb5Hw25EY6ewyUKru7sGEmcgeVZbW6vs7GzfYwB7RauwglZhBa3Ciu7e6vyKjfrJM4u0vrFFQRAoJkaq3tisUIfTuLze+vX5Y3T+uBzFxfKWtUjW3TtF92G5VRZInjU2NvoeAQgLrcIKWoUVtAorumurzjlNe7tMt7+4VFm9kvS5oX3V7pyck/qNSdL54wZqWL9evsdEmLprp+h+LLfKAgkAAABA1Ai1d2hFTaPumbNCLy1ao0kjs3TnV49U7+QE36MBQERjgeRZ//79fY8AhIVWYQWtwgpahRXdodXWUIcefLNEry+v0ZLqBjW3dSguJtDNZ4zUN44frCAIfI+IA9QdOkV0sNwqCyTPLH+EH6ILrcIKWoUVtAorrLdaWtuo787+WAtX12tcXm9dNGGQjshJ09GD0pWbkex7PHQR650ielhulQWSZ7W1tUpLS/M9BrBXtAoraBVW0CqssNqqc06PF1Xo1ueWKDE+Rg9ecrROG2XzwrXYO6udIvpYbpUFEgAAAIBuY0tru57+aLWmvb1Sn6xt1HEFfXTX145SdlqS79EAwDQWSJ6lp6f7HgEIC63CClqFFbQKKyy1+rcPyvWrl5ZpY1ObRg1I1W+/eqTOHTtQMTFc46i7s9QpopvlVlkgeZaSkuJ7BCAstAoraBVW0CqssNLqwsp63fz0Io0blK4fnHKYJgzO4OLYUcRKp4DlVmP2doMgCB4OgqAmrcI2nQAAIABJREFUCIJFOxzLCILg1SAIVnT+Pb3zeBAEwT1BEBQHQbAgCIJxO9znss7brwiC4LIdjh8dBMHCzvvcE0TZq3xFRYXvEYCw0CqsoFVYQauwwkKrLaF2/eDvH6tPSoL+dEmhjhnSh+VRlLHQKSDZbnWvCyRJ0ySdvtOxH0ma45wbJmlO579L0pckDev8a4qk+6WtCydJt0g6RtIESbdsWzp13mbKDvfb+XsBAAAAwG797tUV+mRto+44/wilJcf7HgcAuqW9LpCcc3Ml1e10+GxJ0zv/ebqkc3Y4PsNt9a6k3kEQ9Jd0mqRXnXN1zrkNkl6VdHrn11Kdc+8455ykGTs8VlRISuJifrCBVmEFrcIKWoUVkd7qvFV1emhuiS6ckKuThmf5HgeeRHqnwDaWWw3nDKRd6eecq5akzr9ve6UeKGnH87EqO4/t6XjlLo5HjZycHN8jAGGhVVhBq7CCVmFFJLdavr5JP3h8vvqn9dDNXz7c9zjwKJI7BXZkudWuvoj2rt5o7Pbj+K4fPAimaOvb3ZSTk6Pi4mJJUp8+fZSYmKiqqipJUs+ePZWdna2SkhJJUkxMjIYMGaLKyko1NzdLknJzc9XY2KgNGzZIkjIzMxUXF6fq6mpJWy9slZmZqZUrV0qS4uLilJ+fr4qKCrW0tEiS8vLyVF9fr/r6eklSVlaWgiDQ2rVrJUmpqanKyMhQWVmZJCk+Pl6DBg3SqlWr1NbWtu1nUq9evdTQ0CBJ6tevn5xzqqmpkSSlpaUpLS1N5eXlkqTExETl5uaqrKxMoVBIkjR48GDV1taqsbFRktS/f3+FQiHV1tZK2nqV95SUlO3vtUxKSlJOTo5KS0vV0dEhSSooKNCaNWu0efNmSdKAAQPU0tKi9evXS5IyMjKUnJysysqt+77k5GQNGDBAJSUlcs4pCAIVFBSoqqpKTU1N2vYcNTU1qa6uzvzzlJ+fr7q6uqh+npYuXaqEhASepwh/nvh9qlVra6v69evH8xThz5PE79O2/448T5H9PPH7NEBLlixRQkJCRD1PA3LydOc/PtK0D9YqLibQny4Zpy0NG7Qmip+naP99qqysVEJCAs9ThD9P/D41q7W1VQUFBRH9PO1OsKcvbr9REORL+odzbnTnvy+XdKJzrrrzbWhvOOeGB0HwYOc/P7bj7bb95Zy7uvP4g5Le6PzrdefciM7jF+54uz0pLCx0RUVFe5090hUXF2vo0KG+xwD2ilZhBa3CClqFFZHW6tLqBn139kf6ZG2jvjQ6W7ecOUrZaXbfEoKuEWmd/v/27jy87rLM//jnOTnJyb42aZsm3aGlFMsSNnEUUFYdQcWFUVTc18uZ0fmpMzo64zLOjMu4j6MC6iiCyyAqIiAgspNCgbKVtE2bNG2SZm22k7M8vz/OaSmlbQ6lzXPu5P26rl5JTkJ7a979Uu5+z3OAA7HQqnNurfe+Zd/HD/UpbNdL2v1Kam+T9Ju9Hn9r9tXYTpM0lH2K2x8lneucq8kenn2upD9mP7fLOXda9tXX3rrXzwUAAAAAe/SPTuodVz2gwbGEfvi2Fn33LSexPAKAaTLlHUjOuauVuYNojqRuZV5N7TpJ10paKGmrpNd77/uzS6BvKfNKamOSLvfet2Z/nndI+sfsT/sF7/2V2cdblHmltxJJf5D0YZ/DbVEz5Q6k3bfFAfmOVmEFrcIKWoUV+dJqOu319qse0L0b+/Sr979YxzVVhR4JeSRfOgWmYqHVA92BNOUZSN77Sw/wqZfv52u9pA8e4Oe5QtIV+3m8VdLqqeaYqXbs2KH58+eHHgOYEq3CClqFFbQKK/Kl1W/f1qY7NvTq8xevZnmE58iXToGpWG71UJ/ChsNk92FeQL6jVVhBq7CCVmFFPrR6V9tOffWWDbr4+Ea9+dSFocdBHsqHToFcWG6VBRIAAACAvPVY15A+9LMHtay+XF94zXF5/9QPAJipWCAF1tjYGHoEICe0CitoFVbQKqwI2eraLQO69H/uVUlhgX7w1haVxaY8gQOzFNdUWGG5VRZIgcXj8dAjADmhVVhBq7CCVmFFqFbvbtupy354n2rLinTt+07X4jllQeaADVxTYYXlVlkgBdbX1xd6BCAntAoraBVW0CqsmO5Wvfe6+v6tevtVD6ippkTXvvd0NdWUTusMsIdrKqyw3Cr3gAIAAADIC5t3juqTv35E927q1+lL6/SdN5+omrKi0GMBAMQCKbja2trQIwA5oVVYQauwglZhxXS0mk57/fDOzfryTU+pKBrRl157nN54cjMHZiNnXFNhheVWWSAFVlrK7biwgVZhBa3CClqFFUe61Z0jcf39tQ/rjg29OmfVXH3+4tWaW1l8RH9NzDxcU2GF5VY5Aymwzs7O0CMAOaFVWEGrsIJWYcWRbPWejX268Ot/0b2b+vT5i1frfy47ieURDgnXVFhhuVXuQAIAAAAw7X6zbpv+7pp1WlxXpqsuP0WrGitDjwQAOAgWSIFZvn0NswutwgpahRW0CiuORKs3rt+uv7/2YZ2ypFY/eNvJKo/xnyV4YbimwgrLrTrvfegZDklLS4tvbW0NPQYAAACA5+G2J3v0np+06rgFVfrxO09leQQAecY5t9Z737Lv45yBFNjGjRtDjwDkhFZhBa3CClqFFYez1bvaduq9/7tWK+ZV6MrLT2F5hMOGayqssNwqC6TArN4BhtmHVmEFrcIKWoUVh6vVPzy6XZdf+YCW1JXpx+84VVUlhYfl5wUkrqmww3KrLJACc86FHgHICa3CClqFFbQKKw5Hqz+9b4s+8LMHdVxTla5572mqLSs6DJMBz+CaCisst8oZSAAAAACOiFTa6xt/elpf/9PTOntlg779NyeqpKgg9FgAgIPgDKQ81dXVFXoEICe0CitoFVbQKqw41FbXbxvSa75zl77+p6f1uhOb9L3LTmJ5hCOGayqssNwqp9YFNjY2FnoEICe0CitoFVbQKqx4vq3umkjoKzdt0I/vaVdtWUxff9PxevWaRtNP20D+45oKKyy3ygIJAAAAwAvmvdfvH92uf/3t4+odiestpy7Sx85bwWHZADBDsEAKrKmpKfQIQE5oFVbQKqygVViRS6tb+kb16d88pjs29Gr1gkp9/60tWtNcPQ3TARlcU2GF5VZZIAU2Njam4uLi0GMAU6JVWEGrsIJWYcXBWo0nU/qfP2/St25rU2FBRJ/961W67PTFKojwdDVML66psMJyqxyiHVh/f3/oEYCc0CqsoFVYQauw4kCt3t22Uxd8/S/6ys0bdM6qufrTR1+mt5+xhOURguCaCisst8odSAAAAABy5r3XV2/eoG/e2qZFdaX68TtO0UuPrg89FgDgCGOBFFhdXV3oEYCc0CqsoFVYQauwYu9W48mUPv7LR3Tdui69saVZ/3LRsSouLAg4HZDBNRVWWG6VBVJgsVgs9AhATmgVVtAqrKBVWLG71cGxSb3nJ2t1/+Z+/cN5K/SBM5fJOZ6uhvzANRVWWG6VM5AC6+rqCj0CkBNahRW0CitoFVZ0dXVpx9CEXv/f92jd1kF9/U3H64NnLWd5hLzCNRVWWG6VO5AAAAAAHFDX8KT+6dd3q39kUle942S9eNmc0CMBAAJggRRYWVlZ6BGAnNAqrKBVWEGrsGBD9y79/e87lfTSz959mtY0V4ceCdgvrqmwwnKrLJACmzdvXugRgJzQKqygVVhBq8hn3ntdt26bPnv944pFI7rmnadqxbyK0GMBB8Q1FVZYbpUzkALbuHFj6BGAnNAqrKBVWEGryFcbe0f05h/cp7+75mEtnlOmL1/QyPIIeY9rKqyw3Cp3IAEAAACQ917f/8smffmPGxQrjOjzF6/Wpacs1OZNdv9jBwBw+LBACiwS4SYw2ECrsIJWYQWtIp8MTyT0sWsf1k2Pd+u8Y+fqcxevVkNFsSRahQ10Cisst+q896FnOCQtLS2+tbU19BgAAACAaU9sH9b7/3etOgfG9ckLj9E7zlgs51zosQAAgTjn1nrvW/Z93O7qa4bo7OwMPQKQE1qFFbQKK2gVoY1NJvUfNz6pi751l8YmU7r6PafpnS9Z8pzlEa3CAjqFFZZb5SlsgU1MTIQeAcgJrcIKWoUVtIpQvPf6/aPb9YXfP6HtQxN67YkL9I8XHqM55bH9fj2twgI6hRWWW2WBBAAAAMwS3nt95vrH9ON7tujYxkp9629O0EmLakOPBQAwgAVSYM3NzaFHAHJCq7CCVmEFrWK6pdNen/7Nev30vq1610uW6JMXHqOCyNRnHdEqLKBTWGG5Vc5ACmxkZCT0CEBOaBVW0CqsoFVMp3Ta65+uyyyP3veyZfqnV+a2PJJoFTbQKayw3CoLpMAGBgZCjwDkhFZhBa3CClrFdOnZNaEP//whXX3/Vn3gzGX6+PkrnterrNEqLKBTWGG5VZ7CBgAAAMxA8WRKV97Vrm/d2qZ4MqV/OG+FPnDmsue1PAIAYDcWSIHV19eHHgHICa3CClqFFbSKI8V7rz+s36F/v/FJbekb08tXNuifXnmMltaXH9LPR6uwgE5hheVWWSAFFo3yLYANtAoraBVW0CqOhHs29ulLNz6phzsGdVRDua66/GSduaLhBf2ctAoL6BRWWG6VM5AC2759e+gRgJzQKqygVVhBqzicOgfG9O4ft+rS79+r3uEJ/eclL9KNf/vSF7w8kmgVNtAprLDcqt3VFwAAADDLTSbT+uGdm/WNPz0t56RPXLBSb3/xYhUXFoQeDQAww7BACqy8/NCeiw5MN1qFFbQKK2gVL0TnwJiuf7hLv2jt1Oadozp31Vx95tXHakF1yWH/tWgVFtAprLDcKgukwCwfoIXZhVZhBa3CClrF8zU+mdJvH+nSL1s7dX97vyTphIXV+sFbW/SKVXOP2K9Lq7CATmGF5VZZIAW2efNmLV++PPQYwJRoFVbQKqygVeRqY++Ifnx3u3790DbtmkhqWX2ZPnbu0Xr1mgVaWFd6xH99WoUFdAorLLfKAgkAAADIQ957/eTeLfr8756QJF1w3Dy9+dRFOnlxjZxzgacDAMw2LJACs/wSfphdaBVW0CqsoFUczPBEQp/41SO64dEdOntlg/79dS9SfUUsyCy0CgvoFFZYbtV570PPcEhaWlp8a2tr6DEAAACAw8Z7r5se79YXfv+Etg2O6+Pnr9C7XrJUkQh3HAEApodzbq33vmXfxyMhhsEzOjo6Qo8A5IRWYQWtwgpaxd6897rl8W799bfu1Ht/slYFEadr33ua3vPSZcGXR7QKC+gUVlhu1e69UzNEPB4PPQKQE1qFFbQKK2gVu/WNxPWRn6/TnW07tbC2VF9+/RpdfHyjogX58Xe9tAoL6BRWWG6VBRIAAAAQyCOdg3rfT9Zq5+ikPnfRsXrTKQtVmCeLIwAA9sYCKbCFCxeGHgHICa3CClqFFbQ6u3nvdW1rhz79m8dUXx7Tr9//Yq1eUBV6rP2iVVhAp7DCcqv89UZgQ0NDoUcAckKrsIJWYQWtzl5b+kb19isf0Md/9ahOXlyj3374JXm7PJJoFTbQKayw3CoLpMAsx4PZhVZhBa3CClqdfeLJlL75p6d17tfu0NotA/rnV63Sjy4/RbVlRaFHOyhahQV0Cisst8pT2AAAAIAjbNvguN7/v2v1SOeQXvmi+fr0K1dpXlVx6LEAAMgZC6TAGhoaQo8A5IRWYQWtwgpanT3u3rhTH/rZQ5pMpvXfbzlJ56+eF3qk54VWYQGdwgrLrbJACsw5F3oEICe0CitoFVbQ6sw3NpnUlXe166s3b9CSOWX63mUnaVl9eeixnjdahQV0Cisst8oCKbDu7m5VVFSEHgOYEq3CClqFFbQ6c3UNjutH97Tr6vu2angiqfOPnacvv2GNymM2/+hNq7CATmGF5VZt/lsMAAAAyDNtPbv0nds36vp1XUp7r/NXz9M7zliikxbVmP4bZwAAJBZIwVVWVoYeAcgJrcIKWoUVtDozpNJea7cM6Mq7NuvGx3aoOFqgt56+WJefsVjNtaWhxzssaBUW0CmssNwqC6TAamtrQ48A5IRWYQWtwgpatSuV9rrh0e265Ylu/XlDrwbHEqoojupDZy3X21+8WHXlsdAjHla0CgvoFFZYbjUSeoDZrr29PfQIQE5oFVbQKqygVZu29I3qjd+7Rx+++iHd+fROnb2yQd/6mxN09yfO1kfPXTHjlkcSrcIGOoUVllvlDiQAAABgCt57XX1/hz7/+8dV4Jy+/Po1eu0JCxSJcLYRAGB2YIEUWGFhYegRgJzQKqygVVhBq3Y8tWOX/uW3j+nujX06Y3md/vOSNWqsLgk91rShVVhAp7DCcqvOex96hkPS0tLiW1tbQ48BAACAGWpgdFJfvXmDfnrfFlUUF+pj563Qm09ZyF1HAIAZzTm31nvfsu/jnIEU2JYtW0KPAOSEVmEFrcIKWs1f3nv9am2nzvrK7frZ/Vt12WmLdPvHztRlpy2alcsjWoUFdAorLLfKU9gCSyQSoUcAckKrsIJWYQWt5qeO/jH94/89qr88vVMti2r0hdccpxXzKkKPFRStwgI6hRWWW2WBBAAAgFkvkUrrqrva9bVbNshJ+teLjtVbTp2ddxwBALA/nIEUWDKZVDTKHg/5j1ZhBa3CClrNH3c+vVOf/e1jausZ0Vkr6vW5i1erqaY09Fh5g1ZhAZ3CCgutcgZSnurv7w89ApATWoUVtAoraDWsiURKNzy6XZdfeb/e8sP7NJlM6wdvbdEVbz+Z5dE+aBUW0CmssNxqfq+9ZoHh4WE1NDSEHgOYEq3CClqFFbQaxmNdQ7ryrnbduH6HRuJJ1VfE9NFzjta7X7pUxYUFocfLS7QKC+gUVlhulQUSAAAAZrwH2vv17dvadPtTvSqPRXXB6nm6+IQFOm1pnQo45wgAgCmxQAps7ty5oUcAckKrsIJWYQWtTo/124b0xRue0N0b+1RXVqR/OG+FLjt9kSqLC0OPZgatwgI6hRWWW2WBFJjVQ8wx+9AqrKBVWEGrR1bnwJi+/MendN26LtWWFemfX7VKl56yUCVFPE3t+aJVWECnsMJyqyyQAuvp6VFlZWXoMYAp0SqsoFVYQauHLpX2un9zv256fIcmEilVFheqsqRQk8m0ntwxrCe279LW/jHFohF94Mxlet+Zy7jj6AWgVVhAp7DCcqsskAAAAGBCW8+Irrp7s25c362dI3HFohFVlhRqeDyheDIt56QldWVavaBSb2hp0mtPbFJjdUnosQEAmBFYIAVWVVUVegQgJ7QKK2gVVtBq7rYNjuvrt2zQL9d2qiga0ctXztWFx83XWSvrVVqU+ePsRCIlSbyS2hFAq7CATmGF5VZZIAVmOR7MLrQKK2gVVtDq1BKptL528wb94C+bJSddfsYSfeDMZaorjz3na1kcHTm0CgvoFFZYbjUSeoDZbuvWraFHAHJCq7CCVmEFrR5c1+C43vi9e/Sd2zfqr9c06vaPnalPv2rVfpdHOLJoFRbQKayw3Cp3IAEAACCv3Ppkt/7+2oeVTHl9629O0Kte1Bh6JAAAZj0WSIHFYvwtGmygVVhBq7CCVp+RTns93Dmomx7v1k2P7dDG3lEdM79S33nziVoypyz0eLMercICOoUVllt13vvQMxySlpYW39raGnoMAAAAHKJU2uuGR7frm7c+rQ3dI4pGnE5bWqdzj52rN7Q0c64RAAABOOfWeu9b9n2cM5ACa29vDz0CkBNahRW0Citmc6vee/3+ke06/7/u0IevfkhpL/3HJS/S2k+do/9916l66+mLWR7lkdncKuygU1hhuVWewhZYMpkMPQKQE1qFFbQKK2Zrq209u/Sp69br3k39Wt5Qrm9eeoIuPG6+CiIu9Gg4gNnaKmyhU1hhuVUWSAAAADjixidT+satT+v7d2xSaVGBvvCa1XrTyQtZHAEAYARnIAWWSqVUUMAt2sh/tAoraBVWzKZWH9o6oI9e+7A27RzVJSc16RMXrNSccruHiM42s6lV2EWnsMJCq5yBlKd6e3tDjwDkhFZhBa3CitnQ6mQyra/c9JRe9927NZFI6afvOlVffv0alkfGzIZWYR+dwgrLrfIUtsBGRkZCjwDkhFZhBa3Cipne6obuXfq7a9bpsa5hve7EJn3m1atUWVwYeiwcgpneKmYGOoUVlltlgQQAAIDDJpX2uuLOzfrPm55SRSyq/37LSTp/9bzQYwEAgBeIBVJg8+fPDz0CkBNahRW0CitmYqtPd+/SP123Xvdv7tc5q+bq3157HE9XmwFmYquYeegUVlhulQVSYJZfwg+zC63CClqFFTOp1Z0jcX3t5g36+QMdKi0q0H9e8iJdclKTnOMV1maCmdQqZi46hRWWW2WBFFhvb6+qqqpCjwFMiVZhBa3CipnQajrtdeXd7frazRs0kUjpLacu1EdecbRqy4pCj4bDaCa0ipmPTmGF5VZf0ALJOdcuaZeklKSk977FOVcr6RpJiyW1S3qD937AZf4K6uuSLpQ0Junt3vsHsz/P2yR9KvvTft57/6MXMhcAAACOrO1D4/rotQ/r7o19OmtFvT71qlVaVl8eeiwAAHCEHI47kM7y3u/c6+NPSPqT9/5LzrlPZD/+uKQLJB2V/XGqpO9KOjW7cPqMpBZJXtJa59z13vuBwzBb3qupqQk9ApATWoUVtAorrLaaTnv99pEuffq69Uqmvf79dcfpDS3NPF1tBrPaKmYXOoUVlls9Ek9hu0jSmdn3fyTpdmUWSBdJ+rH33ku61zlX7Zybn/3am733/ZLknLtZ0vmSrj4Cs+Wd8nL+pg420CqsoFVYYa3V7UPj+kVrp655oEPbBsd1wsJqfe0Nx2vxnLLQo+EIs9YqZic6hRWWW428wH/eS7rJObfWOfee7GNzvffbJSn7tiH7+AJJHXv9s53Zxw70+KzQ0dEx9RcBeYBWYQWtwgorrU4kUvrs9Y/pjC/dqq/evEFL5pTpm5eeoF+893SWR7OElVYxu9EprLDc6gu9A+kM732Xc65B0s3OuScP8rX7u6/ZH+Tx5/4EmSXVeySpqalJbW1tkqS6ujrFYjF1dXVJksrKyjRv3jxt3LhRkhSJRLR06VJ1dnZqYmJCktTc3KyRkRENDGSeKVdfX69oNKrt27dLymwF6+vrtXnzZklSNBrV4sWL1dHRoXg8LklauHChhoaGNDQ0JElqaGiQc07d3d2SpMrKStXW1qq9vV2SVFhYqEWLFmnLli1KJBKZ/6Heq6enR8PDw5KkuXPn7nlMkqqqqlRVVaWtW7dKkmKxmJqbm9Xe3r7n9PYlS5aot7dXIyMjkjIvC5hMJtXb2yspc4tceXn5nlCLi4vV1NSkTZs2KZ1OS5KWLVumHTt2aHR0VJLU2NioeDyuvr4+SVJtba1KS0vV2dkpSSotLVVjY6M2btwo772cc1q2bJm6uro0Njam3d+jsbEx9ff3m/8+LV68WP39/bP6+xSPx9XW1sb3Kc+/T/x+6t3z/zXfp/z+Pkn8fvLeq7e3N6+/T9uGJvXFP3frqZ4xvfqYal1yXI2WNlSqqalx1nyf+P3UuOfPAHyf8vv7NNt/P+3ulO9Tfn+f+P00oXg8rng8ntffpwNxB/vk8+Gc+6ykEUnvlnSm93579ilqt3vvVzjnvpd9/+rs1z+lzNPXzsx+/Xuzjz/r6w6kpaXFt7a2HpbZQ+rs7FRTU1PoMYAp0SqsoFVYkc+tptNe//fQNn3m+scULXD68iVr9IpVc0OPhUDyuVVgNzqFFRZadc6t9d63POfxQ10gOefKJEW897uy798s6V8lvVxS316HaNd67/+fc+6Vkj6kzKuwnSrpG977U7KHaK+VdGL2p35Q0km7z0Q6kJmyQAIAAMgXqbTX7x7p0rdva9OG7hGdtKhG37z0BDVWl4QeDQAATJMDLZBeyBlIcyXd6Zx7WNL9kn7vvb9R0pckneOce1rSOdmPJekGSZsktUn6vqQPSFJ2UfQ5SQ9kf/zrVMujmWTTpk2hRwByQquwglZhRT61mkyl9cu1nTrnq3/WR36+Tt5LX3/T8br2vaezPEJetQocCJ3CCsutHvIZSN77TZLW7OfxPmXuQtr3cS/pgwf4ua6QdMWhzmLZ7udmAvmOVmEFrcKKfGh1MpnWrx/s1Ldvb1NH/7iOmV+p7775RJ137DxFIvs7phKzUT60CkyFTmGF5VZf6CHaAAAAMGZT74iube3UL9d2audIXGuaqvSZVx2rlx+TOYATAABgX4ftEO3pNlPOQNp9sjuQ72gVVtAqrJjuVtt3juqWJ7r1x8d26IH2ARVEnM5a0aDLTl+klx41h983OCCuq7CATmGFhVYPdAYSdyAFtmPHDs2fPz/0GMCUaBVW0CqsmI5Wt/SN6lcPbtMNj25XW0/mZZCPnluuj5+/Uq87cYEaKouP6K+PmYHrKiygU1hhuVUWSIGNjo6GHgHICa3CClqFFUeiVe+9NvaO6v7N/bpu3Tbdv7lfzkmnL63Tm09dqJevnKuFdaWH/dfFzMZ1FRbQKayw3CoLJAAAAMNG4kn9/pEu/fGxbj24dUCDYwlJ0tI5ZfqH81botScu0PwqXkkNAAC8MCyQAmtsbAw9ApATWoUVtAorXkir6bRX65YB/aK1Q79/dLvGJlNaXFeq84+dpxMX1ujERdVaVl+e92cswAauq7CATmGF5VZZIAUWj8dVWsqt5Mh/tAoraBVWHEqrj3YO6Tfrtul3j2zXjuEJlRUV6NVrGvWGk5t1QnM1CyMcEVxXYQGdwgrLrbJACqyvr081NTWhxwCmRKuwglZhxfNp9ckdw/riDU/qjg29KixwetnR9frkhSt1zqq5Ki3ij3M4sriuwgI6hRWWW+VPHAAAAHlq2+C4vnHL0/rF2g6Vx6L6xwtX6o0tC1VVWhh6NAAAMMuwQAqstrY29AhATmgVVtAqrDgUZfmtAAAgAElEQVRQq5PJtG59sls/f6BDd2zoVUHE6R1nLNGHzl6u6tKiaZ4S4LoKG+gUVlhulQVSYFaf+4jZh1ZhBa3Cin1bHY0n9dP7tuh/7tisnSNxzass1gfPWq43ntysphq6RjhcV2EBncIKy61GQg8w23V2doYeAcgJrcIKWoUVu1sdGk/oO7e36a/+4zZ98YYntXJeha58+8m66xNn66PnrmB5hOC4rsICOoUVllvlDiQAAIBplk57resa07daH9If1u9QPJnWmSvq9eGzj9JJi2werAkAAGY2FkiBWb59DbMLrcIKWkU+G59M6ZdrO3TFXe3avHNUFcVRvb6lSW86eaFWL6gKPR6wX1xXYQGdwgrLrTrvfegZDklLS4tvbW0NPQYAAMCUhsYS+sGdm/STe7docCyhNc3Vetvpi3TB6vkqKSoIPR4AAMAezrm13vuWfR/nDKTANm7cGHoEICe0CitoFfnEe69fP9ipl3/1dn3rtjadsrhWv3jf6bruAy/Wmqo4yyOYwHUVFtAprLDcKk9hC8zqHWCYfWgVVtAq8kVbz4g+dd2jundTv45vrtZVl5/yrKep0SqsoFVYQKewwnKrLJACc86FHgHICa3CClpFaKm01w/v3KQv37RBJYUF+rfXHqc3tjQrEnl2m7QKK2gVFtAprLDcKmcgAQAAHCZb+kb1D794RPe39+vcVXP1xdcepznlsdBjAQAA5IwzkPJUV1dX6BGAnNAqrKBVhJBKe11512Zd8PW/6Intw/rK69foe5eddNDlEa3CClqFBXQKKyy3ylPYAhsbGws9ApATWoUVtIrptqF7lz7+q0f00NZBvezoev3ba49TY3XJlP8crcIKWoUFdAorLLfKAgkAAOAQTCbT+s7tbfr2bW0qj0X1tTeu0cXHLzB9tgEAAMCBsEAKrKmpKfQIQE5oFVbQKqbDg1sH9IlfPaIN3SN69ZpG/fNfr3reZx3RKqygVVhAp7DCcqsskAIbGxtTcXFx6DGAKdEqrKBVHEmj8aS+fNNTuuruds2rLNYVb2/R2SvnHtLPRauwglZhAZ3CCsutcoh2YP39/aFHAHJCq7CCVnGk3LGhV+d+7Q5deVe73nLqIt30dy895OWRRKuwg1ZhAZ3CCsutcgcSAADAQewYmtB//vEp/erBTi2tL9Mv3ne6Tl5cG3osAACAacUCKbC6urrQIwA5oVVYQas4HLz3WrtlQFfe3a4/rt8hSfrQWcv1obOXq7iw4LD8GrQKK2gVFtAprLDcKgukwGKx53fgJhAKrcIKWsWhmEym9cT2YT3cOah1HYN6aOugNu8cVWVxVJefsViXnbZYC+tKD+uvSauwglZhAZ3CCsutskAKrKurS8uXLw89BjAlWoUVtIpcxJMp3bFhp+5q26l1HYN6vGtYk6m0JKm+Iqbjm6v1rr9aotecsEClRUfmj0u0CitoFRbQKayw3CoLJAAAMKN479U3OqltA+PaNjiuofGEYtGISrJPPbvtqR7duH6HhieSKi0q0HELqnT5GYu1prlaxzdXa35VsZxzgf9XAAAA5BcWSIGVlZWFHgHICa3CClqdvbz3uuHRHfriDU9o2+D4Ab+uPBbVucfO1avXNOqM5XNUWBDmRWlpFVbQKiygU1hhuVXnvQ89wyFpaWnxra2tocd4wbz3/C0nTKBVWEGrs9OG7l36zG8e0z2b+nTM/EpdclKTmmtKtKCmRLVlRYon0hpPpDSZTGvFvIrDdhD2C0GrsIJWYQGdwgoLrTrn1nrvW/Z9nDuQAtu4caPZ5z9idqFVWEGrs8PQeEJ3t+1U65YBtbb369FtQ6ooLtTnLjpWl56yUNFAdxU9H7QKK2gVFtAprLDcKgskAABgyiOdg3rXj1rVsyuuWDSiNc3V+tBZy/X2M5aotqwo9HgAAAAzEgukwCKR/P8bUkCiVdhBqzPb7x7p0kevfVhzymP62btPVcuiWhVFbX7PaRVW0CosoFNYYblVzkACAAB5L532+satT+u/bnlaLYtq9N+XnaQ55bHQYwEAAMw4BzoDye7qa4bo7OwMPQKQE1qFFbQ68wyNJ/Sen7Tqv255Wq87sUk/ffepM2J5RKuwglZhAZ3CCsut8hS2wCYmJkKPAOSEVmEFrc4sj3cN6/0/XattA+P67F+v0ttevDjvX7kkV7QKK2gVFtAprLDcKgskAACQd9p3jur/Htqm792xUVUlhbrmvafppEW1occCAACYtVggBdbc3Bx6BCAntAoraNWWgdFJ3d/er5GJpMYmkxoaT+iWJ3q0rmNQzklnr2jQl173ItVX2H/K2r5oFVbQKiygU1hhuVUWSIGNjIwoFpt5fyjGzEOrsIJW85/3Xvdt7tfV92/VH9bv0GQy/azPr5xXoU9esFKvPr5R86tKAk155NEqrKBVWECnsMJyqyyQAhsYGFBdXV3oMYAp0SqsoNX85L3XE9t36fePdul3j2zXlr4xVRRH9aaTm3XR8Y2aUx5TSVGByoqiKovNjj+e0CqsoFVYQKewwnKrs+NPaAAAIIjxyZR+ubZDP7pni9p6RhRx0ouXzdGHzz5KrzxuvkqKCkKPCAAAgBywQAqsvr4+9AhATmgVVtBqfugbiet/792qH93Trv7RSa1prtbnL16t81fP05xym7dtH260CitoFRbQKayw3CoLpMCiUb4FsIFWYQWthpNKe93ZtlPXPLBVNz/erUTK6+UrG/Tely3TyYtr5JwLPWJeoVVYQauwgE5hheVW7U4+Q2zfvl3Lly8PPQYwJVqFFbQ6vSYSKd2zqU9/eqJbtzzeox3DE6opLdRlpy3Wpac066i5FaFHzFu0CitoFRbQKayw3CoLJAAA8Lx19I/pu3/eqOse2qaxyZRKCgv0kqPm6FPHH6NzVs1VLMrZRgAAADMJC6TAysvLQ48A5IRWYQWtHllb+kb13ds36pdrOxVxThef0KgLjpuv05fWqbiQpdHzQauwglZhAZ3CCsutskAKzPIBWphdaBVW0OrhN5FI6cb1O3Rta4fu3tinomhEbz51od535jLNryoJPZ5ZtAoraBUW0CmssNxqJPQAs93mzZtDjwDkhFZhBa0eXr9c26mTv3CL/vaadeoYGNPfn3O0/vL/ztK/XLSa5dELRKuwglZhAZ3CCsutcgcSAAB4jolESv/y28d19f1bdeqSWn3kFUfptCV1ikR4JTUAAIDZiAVSYJZfwg+zC63CClp9Ybz3erpnRB/7xcN6pHNI7z9zmT56ztGKFnDT8uFGq7CCVmEBncIKy606733oGQ5JS0uLb21tDT0GAACmee/1VPcu3fn0Tj3Q3q+1Wwa0c2RSFbGovvKGNTr32HmhRwQAAMA0cs6t9d637Pu43dXXDNHR0aHm5ubQYwBTolVYQatTS6bS+vOGXt3w6A795ele9eyKS5IW1pbqpUfXq2VRrc5e2aB5VcWBJ53ZaBVW0CosoFNYYblVFkiBxePx0CMAOaFVWEGrB7a1b0zXtnboF2s71D0cV3VpoV6yfI5eelS9/uroORyKPc1oFVbQKiygU1hhuVUWSAAAzGATiZRuerxb1zywVXe19SnipDNXNOhfL2rW2SsbVMjZRgAAAMgBZyAFNjk5qaKiotBjAFOiVVhBq1IildY9G/v0h/U79If12zU4llBTTYne2NKsS1qauNMoT9AqrKBVWECnsMJCq5yBlKeGhoZUX18fegxgSrQKK2Zrq0NjCd3xdK9ue6pHf3qiR0PjCZUVFejlx8zVG1qa9eJldYpEXOgxsZfZ2irsoVVYQKewwnKrLJACsxwPZhdahRWzodV02mvTzlGt3zak9duG9FDHoB7aOqC0l6pLC3X2ygZdeNx8/dVRc1RcWBB6XBzAbGgVMwOtwgI6hRWWW2WBBABAnhuJJ3Xbkz16aOug1m8b0mNdQxqdTEmSiqIRrZpfqQ+etVxnrmjQ8c3VKuBOIwAAABxmLJACa2hoCD0CkBNahRUzpdV4MqW/bNip69Zt0y1PdGsikVZxYUTHzK/U605q0uoFVTpuQZWWN5RzELZRM6VVzHy0CgvoFFZYbpUFUmDO8bfEsIFWYYXlVndNJHTbU7266bEduv2pXo3Ek6opLdQlJzXpouMX6ITmakVZFs0YllvF7EKrsIBOYYXlVlkgBdbd3a2KiorQYwBTolVYYa3ViURKtz7Zo+vXdenWp3o0mUxrTnmRXvWi+Trv2Hl6yVFzuMNohrLWKmYvWoUFdAorLLfKAgkAgGkykUipd1dcG7p3aV3HoNZ1DOrBLQManUxpTnlMf3PKQr3yRfN14sIazjECAABAXmGBFFhlZWXoEYCc0CqsyJdWOwfG9EB7v+7fPKCHtg5o+9CEhsYTez5fEHFaMbdCrzlxgc4/dr5OX1bH0miWyZdWganQKiygU1hhuVUWSIHV1taGHgHICa3Ciulu1XuvzoFxtW7p12PbhvXkjl16csewdo5MSpIqYlGdsKhGpyypVUNFTA0VxVo8p0yrF1SqtIh/Dc9mXFdhBa3CAjqFFZZb5U+ugbW3t2v58uWhxwCmRKuw4ki1mkyltb5rWFv6RtW7K67ekbg6+se0dsuAuofjkqRYNKKj51bo7JUNWjW/UicvqdXKeZXcWYT94roKK2gVFtAprLDcKgskAAD24r3X0HhCnQPj2jY4rvado7pvc7/u39yvkXhyz9cVFjjNqyrWaUvr1LKoRictqtXRc8t5lTQAAADMSCyQAissLAw9ApATWoUVz7fVRCqtdR2DWrslc1bRQ1sH1bMr/qyvWTqnTK8+vlGnL63TMfMrVV8eU2VJ1PTLsCI8rquwglZhAZ3CCsutOu996BkOSUtLi29tbQ09BgDAoK7Bcd2zsU+3PtWjOzb0atdE5s6iJXPKdEJztY6ZX6mmmhItqClRU02pasuKAk8MAAAATA/n3Frvfcu+j3MHUmBbtmzRokWLQo8BTIlWYcXerSZSaXUOjGvzzhFt6h3VI51DWrtlQNsGxyVJ9RUxXbB6ns5e2aBTltSxKMK04roKK2gVFtAprLDcKgukwBKJxNRfBOQBWoUF3cMTuuWpfm17ZFRrt/Trsa5hJdPP3Gk7tzKmlkW1eudLluiUJbVaNb9SEQ64RiBcV2EFrcICOoUVlltlgQQAMMN7r4GxhHYMTWhgbFIDY5PqGY7r4c7MGUadA5k7i2LRiNY0V+udf7VEy+vLtWROmRbPKVNdWRHnFgEAAACHgDOQAksmk4pG2eMh/9EqplPfSFwPbh1UR/+YOgbG1NE/rs6BMXX0j2l0MvWcr6+viGVfCa1GJzRX6rimWhVFeTU05Deuq7CCVmEBncIKC61yBlKe6u/vV0NDQ+gxgCnRKg6XVNprYGxSvbvi6huZVCKVVjLtlUyl9fj2Yf15Q68e3Tak3X+/UVpUoOaaUjXXlui0pXVqri1VY1WxasqKVFtWpJrSIs0pf+bOop6eHpZHMIHrKqygVVhAp7DCcqsskAIbHh42Gw9mF1rFwXjvNTyRVO+ueObHSHzP+zv3er93JK6+kbjSB7j5NeKkExbW6O9ecbRevKxOS+vLVVNa+LyedkarsIJWYQWtwgI6hRWWW2WBBAA4qGQqrY6BcW3qHVHX4Hh2ETS5ZyG0M7scmkyln/PPFhY41ZfHVF8RU2N1sV7UVKX6iszH9eUx1ZYVKVZYoGjEKeKcFlSXqKq0MMD/SgAAAAAHwwIpsLlz54YeAcgJrc5M6bTX9uEJbR8cV/dwXN3DE+reNaGe7Ps7hibUMTCmROqZW4ack+rKYnsWQcvqy/YshHY/1lAR05zymKpKnt/dQ4cDrcIKWoUVtAoL6BRWWG6VBVJgVg8xx+xDq7ZNJFLq6B9TW8+INvaOqK1nRG29I9rUO6qxfQ6lLiqIqKEyprmVxVo5v0LnrZ6npXPKtLS+XM01JaotK1K0IH/PGKJVWEGrsIJWYQGdwgrLrbJACqynp0eVlZWhxwCmRKv5IZ322jWR3PMS9oPjCU1MpjSZSiueSGt4IqHeXXH17IqrJ3snUc+uuIbGE8/6eRZUl2hpfZneeHKtltWXq7m2VHMrY5pbUazq53nmUL6hVVhBq7CCVmEBncIKy62yQAKAgLz32jkyqfa+Ue0YmtDgeEJDY5MaGEtocCyhofHM+wNjkxocS2hwbPKAB1DvVlQQyTyNrDKmpfVlOm1pnRoqYmqqLdHy+gotrS9TWYzLPwAAAIDc8V8QgVVVVYUeAcgJrR66kXhSnQNj6uwfz7wdGFfHwJg6+se1tX9MI/Hkc/6Z0qIC1ZQWqaqkUNWlhTpmXqWqSwtVU1q0521NWaGqSopUWlSgWDSiomhE5bFokHOH8gmtwgpahRW0CgvoFFZYbpUFUmCW48HsQqsZ3nvFk2ntmkhqJJ7UyERSu+KZp411Doyrc2Bc24fGNTD6zJ1DuyaevSAqLoyoqaZUTTUlOmVJrRbVlWrxnDItqC5RdWmhqkoKFYsWBPpfaB+twgpahRW0CgvoFFZYbpUFUmBbt27V8uXLQ48BTGmmteq91654UgOjk+obndzztn+v9wdGM8ufXfGkRuKJzNJoIqnkQZ5DVldWpPnVxaoti2nxnDLVlBZpXlWxmmpK9iyN6sqKZvUdQkfaTGsVMxetwgpahQV0Cisst8oCCYAJyVRag+OZM4BG4ymNTaY0nkhqbDL7/p632ccSux9LPvvziZRG45lDqPd+afq9FUUjqisr2vMUsqaaElXEKlReHFV5LKry4qgqigtVEXvm4znlRWqsLlFpEZdVAAAAADMP/6UTWCwWCz0CkJP9teq910g8qfHJlCIRpwLn5Jw0mUprMpn5EXFOxYWZM3oKCtyex+PJtIbHE3uWQkPjCQ2MJjQ4Pqmh3YdGjyc0NJZQf/bzub7iZUlhgUqLClQaK1BpYVQlRZmPq0sLVVIUVVlRgWrKilRbWqTasuf+KC0q4A4hw7iuwgpahRW0CgvoFFZYbtX5XP+LLM+0tLT41tbW0GMAJu1e/AyMZhY1/WOTGhybVP9oIvs284pfE4mUEmmvVDqtRMorlfZKptKaTHkNjU1q5+ikJpPpwzpbRSyqqtLMwdHVJZkDo6tLC1VbFlNdWebjsqKoSosKsouhvd8vUHG0QJEIyx8AAAAAOBTOubXe+5Z9H+cOpMDa29u1ePHi0GNgGnjvNZlKa2IyrfFE5qlV44mUJhIpje/12ET2qVfjifSez49NJjU+mc58bs/nU3JOKo4WqLgwouLCApUUFihWmPk4nc78evFkWmPx1J6Xgd+9LDrQ07ciTqrOvtJXSWGBogURFUacEpNxVZSVKlocVTQS0bGNlaorL9KcsphKigqU9l7ptFfaS4XRiGIFmVcFS2cPnY4nUkqmvYqiERVlP1dZnF0UZX+9qpJCFRZEpvk7g5mG6yqsoFVYQauwgE5hheVWWSAFlkw+9+W7kR9Saa/RyaRG40mNxjPn5mQ+zix0RuJJjcVTmbeTSY1kv2bP5yZTe75m9z97kLOXD6ikMHN3zbPeFhaoojjz23cikdLOkcziaSKZWUbFE5mnlO1e1pRmn7K1eE6pTiyrVnVp5ulbmTt7ijIflxWpprRQlcWF+72Dp62tzexhb5hduK7CClqFFbQKC+gUVlhulQUSpk0q7TU8ntDwREJjkyklUmklUmlNJjN3yiSS2Y+z5+ckUl6TyVTmbfZOmqGxSfWPJTKvjhVPKp5IKZ7M3Jmz99v0fp6aue9KZN8zbvb9/MFeaWtfJYUFKotFVRYrUFlR5m1tWZGaa0pVFss8zWr32+Ls+TwlhQWZu4aKnvvx7jN8YtEIZ/EAAAAAAILjDKTAUqmUCgoKQo/xvKTTXjtH4+oeiqt3ZEJD4wkNjyc1NJ7Ivp945v2J5J6PR+IvfNNaVVK456Dj8lhUxYURxaKZRcvug5pjhREV7LN02bfyfbP3+3yF95lX4iqPRfcsf3a/Xx6LqnTPx5mlUMEsOHPHYquYnWgVVtAqrKBVWECnsMJCq5yBlKd6e3s1b948SZkzcpJpr2TKK5HO3IXz7KdIPfO0qL1fknzfM3ImU2l5n/n5JKkwe97Mnh8FEcWiEUUiTqm0VyKVVjLllcwelJxMpZXIHpaczN79MxJPatdEUrsmEuobmTzg3TllRQWqKilUZfbHguoSrZpfmX0smnlbXKiyWIEKCyJ7ZisseOZcnMIC98zMBREVZh8rKuBunJD2bhXIZ7QKK2gVVtAqLKBTWGG5VRZIAd38eLc+cvVDSkvZBc6h3Q1WXBhRaVE0+xSozDIm4pwikcydNIm9XlJ991PBJrNP84pGIopGnKIFbs9hydGCiKIFToWRiAqy5+hUFEc1r7JYFcVRzSmPaV5VseZVFqu+Iqbq0iJVlRSqojjKAcgz2MjISOgRgJzQKqygVVhBq7CATmGF5VZZIAW0oLpE5x9dpTl1NdklzjMLnMKCzOIm85Sp3WfoPHPGzu6nTu2+kwgAAAAAAOBIyZsFknPufElfl1Qg6Qfe+y8FHumIW9VYqc+9do3KyspCjwJMaf78+aFHAHJCq7CCVmEFrcICOoUVllvNi+cbOecKJH1b0gWSVkm61Dm3KuxU08PyS/hhdqFVWEGrsIJWYQWtwgI6hRWWW82LBZKkUyS1ee83ee8nJf1c0kWBZ5oWvb29oUcAckKrsIJWYQWtwgpahQV0Cisst5ovC6QFkjr2+rgz+xgAAAAAAAACy5czkPZ3CvRzXpLMOfceSe+RpKamJrW1tUmS6urqFIvF1NXVJUkqKyvTvHnztHHjRklSJBLR0qVL1dnZqYmJCUlSc3OzRkZGNDAwIEmqr69XNBrV9u3bJUnl5eWqr6/X5s2bJUnRaFSLFy9WR0eH4vG4JGnhwoUaGhrS0NCQJKmhoUHOOXV3d0uSKisrVVtbq/b2dklSYWGhFi1apC1btiiRSOz5mp6eHg0PD0uS5s6dK++9enp6JElVVVWqqqrS1q1bJUmxWEzNzc1qb2/fc+vbkiVL1Nvbu+c09/nz5yuZTO7ZbNbU1Ki8vFwdHZkdXXFxsZqamrRp0yal02lJ0rJly7Rjxw6Njo5KkhobGxWPx9XX1ydJqq2tVWlpqTo7OyVJpaWlamxs1MaNG+W9l3NOy5YtU1dXl8bGxrT7ezQ2Nqb+/n7z36fFixerv79/Vn+fUqmU2tra+D7l+feJ30+9SqVS6uvr4/uU598nid9PlZWV6u3t5fuU598nfj817vkzAN+n/P4+zfbfT7s75fuU398nfj9NKJVKKR6P5/X36UDcwT45XZxzp0v6rPf+vOzHn5Qk7/2/HeifaWlp8a2trdM04ZETj8cVi8VCjwFMiVZhBa3CClqFFbQKC+gUVlho1Tm31nvfsu/j+fIUtgckHeWcW+KcK5L0JknXB55pWuzelgL5jlZhBa3CClqFFbQKC+gUVlhuNS+ewua9TzrnPiTpj5IKJF3hvX8s8FgAAAAAAABQniyQJMl7f4OkG0LPMd2Ki4tDjwDkhFZhBa3CClqFFbQKC+gUVlhuNS/OQDoUM+UMJAAAAAAAgHyR72cgzVqbNm0KPQKQE1qFFbQKK2gVVtAqLKBTWGG5VRZIge1+eUEg39EqrKBVWEGrsIJWYQGdwgrLrbJAAgAAAAAAwEFxBlJg3ns550KPAUyJVmEFrcIKWoUVtAoL6BRWWGiVM5Dy1I4dO0KPAOSEVmEFrcIKWoUVtAoL6BRWWG6VBVJgo6OjoUcAckKrsIJWYQWtwgpahQV0Cisst8oCCQAAAAAAAAfFAimwxsbG0CMAOaFVWEGrsIJWYQWtwgI6hRWWW2WBFFg8Hg89ApATWoUVtAoraBVW0CosoFNYYblVFkiB9fX1hR4ByAmtwgpahRW0CitoFRbQKayw3CoLJAAAAAAAAByU896HnuGQOOd6JW0JPcdhMEfSztBDADmgVVhBq7CCVmEFrcICOoUVFlpd5L2v3/dBswukmcI51+q9bwk9BzAVWoUVtAoraBVW0CosoFNYYblVnsIGAAAAAACAg2KBBAAAAAAAgINigRTe/4QeAMgRrcIKWoUVtAoraBUW0CmsMNsqZyABAAAAAADgoLgDCQAAAAAAAAfFAikg59z5zrmnnHNtzrlPhJ4H2Jtzrt0596hzbp1zrjX7WK1z7mbn3NPZtzWh58Ts45y7wjnX45xbv9dj+23TZXwje519xDl3YrjJMZscoNPPOue2Za+r65xzF+71uU9mO33KOXdemKkxGznnmp1ztznnnnDOPeac+0j2ca6ryCsHaZVrK/KKc67YOXe/c+7hbKv/kn18iXPuvux19RrnXFH28Vj247bs5xeHnP9gWCAF4pwrkPRtSRdIWiXpUufcqrBTAc9xlvf++L1eZvITkv7kvT9K0p+yHwPT7SpJ5+/z2IHavEDSUdkf75H03WmaEbhKz+1Ukr6Wva4e772/QZKy//5/k6Rjs//Md7J/TgCmQ1LSR733x0g6TdIHs01yXUW+OVCrEtdW5Je4pLO992skHS/pfOfcaZL+XZlWj5I0IOmd2a9/p6QB7/1ySV/Lfl1eYoEUzimS2rz3m7z3k5J+LumiwDMBU7lI0o+y7/9I0sUBZ8Es5b2/Q1L/Pg8fqM2LJP3YZ9wrqdo5N396JsVsdoBOD+QiST/33se995sltSnz5wTgiPPeb/feP5h9f5ekJyQtENdV5JmDtHogXFsRRPb6OJL9sDD7w0s6W9Ivs4/ve13dfb39paSXO+fcNI37vLBACmeBpI69Pu7UwS+AwHTzkm5yzq11zr0n+9hc7/12KfMvcUkNwaYDnu1AbXKtRb75UPZpP1fs9TRgOkVeyD5t4gRJ94nrKvLYPq1KXFuRZ5xzBc65dZJ6JN0saaOkQe99Mvsle/e4p9Xs54ck1U3vxLlhgRTO/jaKvCQe8skZ3vsTlYZpvxIAAAKDSURBVLlV/YPOuZeGHgg4BFxrkU++K2mZMrezb5f0lezjdIrgnHPlkn4l6W+998MH+9L9PEavmDb7aZVrK/KO9z7lvT9eUpMyd74ds78vy7410yoLpHA6JTXv9XGTpK5AswDP4b3vyr7tkfR/ylz4unffpp592xNuQuBZDtQm11rkDe99d/YPlGlJ39czT6WgUwTlnCtU5j/If+q9/3X2Ya6ryDv7a5VrK/KZ935Q0u3KnNtV7ZyLZj+1d497Ws1+vkq5Pw1+WrFACucBSUdlT2IvUuaAt+sDzwRIkpxzZc65it3vSzpX0nplGn1b9sveJuk3YSYEnuNAbV4v6a3ZVw06TdLQ7qdkANNtn3NiXqPMdVXKdPqm7KuwLFHmcOL7p3s+zE7ZczZ+KOkJ7/1X9/oU11XklQO1yrUV+cY5V++cq86+XyLpFcqc2XWbpEuyX7bvdXX39fYSSbd67/PyDqTo1F+CI8F7n3TOfUjSHyUVSLrCe/9Y4LGA3eZK+r/s2W1RST/z3t/onHtA0rXOuXdK2irp9QFnxCzlnLta0pmS5jjnOiV9RtKXtP82b5B0oTIHZ45JunzaB8asdIBOz3TOHa/Mbentkt4rSd77x5xz10p6XJlXGfqg9z4VYm7MSmdIukzSo9nzOiTpH8V1FfnnQK1eyrUVeWa+pB9lX/UvIula7/3vnHOPS/q5c+7zkh5SZiGq7NufOOfalLnz6E0hhs6Fy9PFFgAAAAAAAPIET2EDAAAAAADAQbFAAgAAAAAAwEGxQAIAAAAAAMBBsUACAAAAAADAQbFAAgAAAAAAwEGxQAIAAAAAAMBBsUACAAAAAADAQbFAAgAAAAAAwEH9f8ipciH/vb8+AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 1440x1080 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plot the data\n",
    "plt.figure(figsize=(20,15))\n",
    "\n",
    "ax0 = plt.subplot2grid((10, 8), (0, 0), rowspan=6, colspan=8)\n",
    "\n",
    "ax0.plot(new_data, label=\"Actual\")\n",
    "\n",
    "ax0.legend(fontsize=\"xx-large\")\n",
    "ax0.grid(True, linestyle='--', color='lightgray')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "# load data array into pandas dataframe\n",
    "new_df = pd.DataFrame(new_data, columns=['GDP'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df = new_df[1:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "#function for finding gdp growth for a quarter\n",
    "def get_gdp_growth(index):\n",
    "    current_value = new_data[index][0]\n",
    "    previous_value = new_data[index-1][0]\n",
    "    \n",
    "    return (math.pow(current_value / previous_value, 4) - 1) * 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#load gdp growth data\n",
    "gdp_pct_df = pd.read_csv('GDP_PCT.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>GDP</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2018-07-01</th>\n",
       "      <td>4.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2018-10-01</th>\n",
       "      <td>2.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-01-01</th>\n",
       "      <td>3.9</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-01</th>\n",
       "      <td>4.7</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-01</th>\n",
       "      <td>3.8</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            GDP\n",
       "DATE           \n",
       "2018-07-01  4.8\n",
       "2018-10-01  2.9\n",
       "2019-01-01  3.9\n",
       "2019-04-01  4.7\n",
       "2019-07-01  3.8"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gdp_pct_df.tail()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# copy gdp pct data to final_df\n",
    "final_df = gdp_pct_df\n",
    "\n",
    "# add the 7 predicted quarters to the gdp growth data\n",
    "for i in range(-7, 0):\n",
    "    final_df = final_df.append({'GDP': get_gdp_growth(i)}, ignore_index=True)\n",
    "    \n",
    "final_df.index = gdp_pct_df.index.append(pd.Index([\"2019-10-01\", \"2020-01-01\", \"2020-04-01\", \"2020-07-01\", \"2020-10-01\", \"2021-01-01\", \"2021-04-01\"]))\n",
    "new_df.index = gdp_pct_df.index.append(pd.Index([\"2019-10-01\", \"2020-01-01\", \"2020-04-01\", \"2020-07-01\", \"2020-10-01\", \"2021-01-01\", \"2021-04-01\"]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>GDP</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-01-01</th>\n",
       "      <td>3.900000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-01</th>\n",
       "      <td>4.700000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-01</th>\n",
       "      <td>3.800000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-10-01</th>\n",
       "      <td>-18.488588</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>17.337566</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-04-01</th>\n",
       "      <td>-9.270814</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-07-01</th>\n",
       "      <td>17.026945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-10-01</th>\n",
       "      <td>-9.446802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-01</th>\n",
       "      <td>1.917489</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-04-01</th>\n",
       "      <td>1.706170</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                  GDP\n",
       "2019-01-01   3.900000\n",
       "2019-04-01   4.700000\n",
       "2019-07-01   3.800000\n",
       "2019-10-01 -18.488588\n",
       "2020-01-01  17.337566\n",
       "2020-04-01  -9.270814\n",
       "2020-07-01  17.026945\n",
       "2020-10-01  -9.446802\n",
       "2021-01-01   1.917489\n",
       "2021-04-01   1.706170"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df.tail(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020 Q4 gdp growth is -9.446802422992196%\n"
     ]
    }
   ],
   "source": [
    "# print 2020 Q4 gdp growth value\n",
    "print(f'2020 Q4 gdp growth is {final_df.values[-3][0]}%')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set index name to DATE\n",
    "final_df.index.name = \"DATE\"\n",
    "new_df.index.name = \"DATE\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>GDP</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1947-04-01</th>\n",
       "      <td>4.700000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1947-07-01</th>\n",
       "      <td>6.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1947-10-01</th>\n",
       "      <td>17.300000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1948-01-01</th>\n",
       "      <td>9.600000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1948-04-01</th>\n",
       "      <td>10.700000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-04-01</th>\n",
       "      <td>-9.270814</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-07-01</th>\n",
       "      <td>17.026945</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-10-01</th>\n",
       "      <td>-9.446802</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-01</th>\n",
       "      <td>1.917489</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-04-01</th>\n",
       "      <td>1.706170</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>297 rows × 1 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                  GDP\n",
       "DATE                 \n",
       "1947-04-01   4.700000\n",
       "1947-07-01   6.000000\n",
       "1947-10-01  17.300000\n",
       "1948-01-01   9.600000\n",
       "1948-04-01  10.700000\n",
       "...               ...\n",
       "2020-04-01  -9.270814\n",
       "2020-07-01  17.026945\n",
       "2020-10-01  -9.446802\n",
       "2021-01-01   1.917489\n",
       "2021-04-01   1.706170\n",
       "\n",
       "[297 rows x 1 columns]"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "final_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>GDP</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>DATE</th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2019-01-01</th>\n",
       "      <td>21098.827000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-04-01</th>\n",
       "      <td>21340.267000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-07-01</th>\n",
       "      <td>21542.104000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2019-10-01</th>\n",
       "      <td>20468.816028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-01-01</th>\n",
       "      <td>21303.550564</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-04-01</th>\n",
       "      <td>20791.639919</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-07-01</th>\n",
       "      <td>21625.203962</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2020-10-01</th>\n",
       "      <td>21095.322052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-01-01</th>\n",
       "      <td>21195.728052</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2021-04-01</th>\n",
       "      <td>21285.564065</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                     GDP\n",
       "DATE                    \n",
       "2019-01-01  21098.827000\n",
       "2019-04-01  21340.267000\n",
       "2019-07-01  21542.104000\n",
       "2019-10-01  20468.816028\n",
       "2020-01-01  21303.550564\n",
       "2020-04-01  20791.639919\n",
       "2020-07-01  21625.203962\n",
       "2020-10-01  21095.322052\n",
       "2021-01-01  21195.728052\n",
       "2021-04-01  21285.564065"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_df.tail(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# save final_df to final_gdp_pct.csv file\n",
    "final_df.to_csv('final_gdp_pct.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_df.to_csv('final_gdp.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
